{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ch00-000",
   "metadata": {},
   "source": [
    "# 00장 실습. 학습 안내와 실습 환경\n",
    "\n",
    "**목표:** 이후 모든 장의 실습을 돌릴 환경을 점검하고, 버전·장치·재현·시간·메모리를 확인하는 작은 도구를 직접 만든다.\n",
    "\n",
    "- 빈칸(`# 작성하세요`)을 채우고 바로 아래 점검 셀을 실행하면 \"통과\"가 나온다.\n",
    "- 막히면 `힌트`를 연다. 다 푼 뒤 `실습/해설/`의 같은 파일과 비교한다.\n",
    "- 끝나면 **커널 재시작 후 모두 실행**(Restart & Run All)으로 처음부터 통과하는지 확인한다.\n",
    "\n",
    "권장 시간: 1시간. CPU로 1분 안에 끝난다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch00-001",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "import hashlib, sys, time, random\n",
    "import numpy as np\n",
    "import torch\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",
    "print(sys.version.split()[0], \"| numpy\", np.__version__, \"| torch\", torch.__version__)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch00-002",
   "metadata": {},
   "source": [
    "## 문제 1. 가상환경 (개념)\n",
    "\n",
    "가상환경(venv)을 쓰는 가장 중요한 이유를 고르세요. `q1`에 `\"A\"`~`\"D\"` 중 하나를 적습니다.\n",
    "\n",
    "- A. 파이썬 코드가 더 빨리 실행된다.\n",
    "- B. 프로젝트마다 라이브러리와 버전을 따로 두어, 한 프로젝트의 설치가 다른 프로젝트를 깨뜨리지 않게 한다.\n",
    "- C. GPU를 쓰려면 반드시 가상환경이 있어야 한다.\n",
    "- D. 인터넷 없이도 패키지를 설치할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch00-003",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "q1 = \"B\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch00-004",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q1\", q1, \"df7e70e50215\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch00-005",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> venv는 실행 속도·GPU·오프라인 설치와 관계없다. 폴더 하나에 인터프리터와 패키지를 따로 두는 것이 핵심이고, 망가지면 그 폴더만 지우고 다시 만들면 된다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch00-006",
   "metadata": {},
   "source": [
    "## 문제 2. 노트북에서만 나는 오류 (사례)\n",
    "\n",
    "터미널에서 `python -c \"import sklearn\"`은 오류 없이 끝난다. 그런데 VS Code 노트북에서 `import sklearn`을 실행하면 `ModuleNotFoundError: No module named 'sklearn'`이 난다.\n",
    "\n",
    "(a) 가장 가능성 높은 원인을 `q2`에 적으세요.\n",
    "\n",
    "- A. scikit-learn이 이 PC에 전혀 설치되지 않았다.\n",
    "- B. 노트북 커널이 터미널과 다른 파이썬 인터프리터로 실행되고 있다.\n",
    "- C. scikit-learn은 Jupyter에서 쓸 수 없다.\n",
    "- D. 노트북 파일 인코딩이 UTF-8이 아니다.\n",
    "\n",
    "(b) 원인을 확인하려면 노트북에서 무엇을 출력해야 할까요? 지금 커널의 파이썬 실행 파일 경로를 `kernel_python`에 문자열로 저장하세요.\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "`sys` 모듈에 실행 파일 경로를 담은 속성이 있습니다. 원고 0-3절 \"VS Code에서 노트북 열기\"를 보세요.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch00-007",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "q2 = \"B\"\n",
    "kernel_python = sys.executable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch00-008",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q2\", q2, \"df7e70e50215\")\n",
    "from pathlib import Path\n",
    "assert isinstance(kernel_python, str), \"경로를 문자열로 저장하세요\"\n",
    "assert Path(kernel_python).resolve() == Path(sys.executable).resolve(), \"지금 커널의 파이썬 실행 파일이 아닙니다\"\n",
    "print(\"커널 파이썬:\", kernel_python)\n",
    "print(\"venv 사용 중:\", sys.prefix != sys.base_prefix)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch00-009",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> 터미널의 `python`과 노트북 커널의 `python`이 다르면 한쪽에만 설치된 패키지가 생긴다. `sys.executable`을 출력해 `.venv` 경로가 아니면 커널을 바꾼다. 같은 이유로 노트북 안에서 설치해야 할 때는 `%pip install ...`(지금 커널에 설치)을 쓴다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch00-010",
   "metadata": {},
   "source": [
    "## 문제 3. 버전 표 (코드)\n",
    "\n",
    "패키지 이름 리스트를 받아 `{이름: 버전}` 딕셔너리를 돌려주는 `versions(names)`를 완성하세요. 설치되지 않은 패키지는 오류 대신 `\"없음\"`을 넣습니다.\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "`importlib.metadata`의 `version(name)`은 설치된 버전 문자열을 돌려주고, 없으면 `PackageNotFoundError`를 냅니다. `try`/`except`로 잡으세요.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch00-011",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "from importlib.metadata import version, PackageNotFoundError\n",
    "\n",
    "def versions(names):\n",
    "    out = {}\n",
    "    for name in names:\n",
    "        try:\n",
    "            out[name] = version(name)\n",
    "        except PackageNotFoundError:\n",
    "            out[name] = \"없음\"\n",
    "    return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch00-012",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "v = versions([\"numpy\", \"torch\", \"scikit-learn\", \"없는패키지-xyz\"])\n",
    "assert list(v) == [\"numpy\", \"torch\", \"scikit-learn\", \"없는패키지-xyz\"], \"입력 순서대로 모든 이름이 있어야 합니다\"\n",
    "from importlib.metadata import version as _ver\n",
    "for k in [\"numpy\", \"torch\", \"scikit-learn\"]:\n",
    "    assert v[k] == _ver(k), f\"{k} 버전이 설치 정보와 다릅니다\"\n",
    "assert versions([]) == {}, \"빈 리스트에는 빈 딕셔너리\"\n",
    "assert versions([\"pandas\"]) == {\"pandas\": _ver(\"pandas\")}\n",
    "assert v[\"없는패키지-xyz\"] == \"없음\"\n",
    "for k, x in v.items():\n",
    "    print(f\"{k:<16}{x}\")\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch00-013",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> `import` 하지 않고 설치 정보만 읽으므로 무거운 패키지도 빠르게 확인한다. 설치 이름(`scikit-learn`)으로 묻는다는 점에 주의한다. import 이름(`sklearn`)으로 물으면 `\"없음\"`이 나온다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch00-014",
   "metadata": {},
   "source": [
    "## 문제 4. 장치 고르기 (코드)\n",
    "\n",
    "(a) GPU를 쓸 수 있으면 `\"cuda\"`, 아니면 `\"cpu\"`를 돌려주는 `pick_device()`를 완성하세요.\n",
    "\n",
    "(b) `a`를 그 장치로 옮긴 텐서를 `b`에 저장하세요. `a`는 CPU에 그대로 둡니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch00-015",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "def pick_device():\n",
    "    return \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "\n",
    "device = pick_device()\n",
    "a = torch.arange(6.0).reshape(2, 3)\n",
    "b = a.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch00-016",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "assert device == (\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "assert b is not None and b.device.type == device, \"b가 지정한 장치에 있지 않습니다\"\n",
    "assert a.device.type == \"cpu\", \"a는 CPU에 남아 있어야 합니다\"\n",
    "assert torch.equal(b.cpu(), a)\n",
    "print(\"device:\", device, \"/ 통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch00-017",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> 텐서의 `.to(device)`는 원본을 바꾸지 않고 결과를 돌려준다(장치가 다르면 복사본, 이미 같으면 원본 그대로). 그래서 `a.to(device)`만 쓰고 결과를 받지 않으면 아무것도 바뀌지 않는다. 계산 결과를 NumPy로 바꾸거나 출력할 때는 `.cpu()`로 되돌린다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch00-018",
   "metadata": {},
   "source": [
    "## 문제 5. 실행 순서 예측 (개념)\n",
    "\n",
    "노트북에 세 셀이 있습니다.\n",
    "\n",
    "```\n",
    "[셀 A]  n = 10\n",
    "[셀 B]  n = n * 2\n",
    "[셀 C]  print(n)\n",
    "```\n",
    "\n",
    "(a) A → B → C → B → C 순서로 실행했을 때, **마지막 C**가 출력하는 값을 `q5a`에 정수로 적으세요.\n",
    "\n",
    "(b) 그 뒤 **커널 재시작 후 모두 실행**을 했을 때 C가 출력하는 값을 `q5b`에 적으세요.\n",
    "\n",
    "직접 실행해 보지 말고 먼저 예측하세요."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch00-019",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "q5a = 40\n",
    "q5b = 20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch00-020",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q5a\", q5a, \"d59eced1ded0\")\n",
    "check(\"q5b\", q5b, \"f5ca38f748a1\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch00-021",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> 커널은 실행 순서대로 상태를 쌓는다. B를 두 번 실행해 10 → 20 → 40. 재시작하면 상태가 지워지고 위에서부터 한 번씩 실행되므로 20이다. 제출 전 Restart & Run All을 하는 이유다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch00-022",
   "metadata": {},
   "source": [
    "## 문제 6. 시드 고정 (코드)\n",
    "\n",
    "`random`, NumPy 전역 난수, PyTorch 난수를 한 번에 고정하는 `set_seed(seed)`를 완성하세요."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch00-023",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "def set_seed(seed):\n",
    "    random.seed(seed)\n",
    "    np.random.seed(seed)\n",
    "    torch.manual_seed(seed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch00-024",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "def draw():\n",
    "    return random.random(), float(np.random.rand()), torch.rand(1).item()\n",
    "\n",
    "set_seed(7); r1 = draw()\n",
    "set_seed(7); r2 = draw()\n",
    "set_seed(8); r3 = draw()\n",
    "assert r1 == r2, \"같은 시드인데 결과가 다릅니다. 세 라이브러리를 모두 고정했나요?\"\n",
    "assert all(x != y for x, y in zip(r1, r3)), \"시드를 바꿨는데 같은 값이 나옵니다\"\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch00-025",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> 세 라이브러리의 난수 생성기는 서로 독립이라 하나만 고정하면 나머지는 매번 달라진다. `torch.manual_seed`는 CPU와 모든 GPU 장치의 시드를 함께 정한다. 다만 GPU 연산 자체가 비결정적인 경우는 시드로 막을 수 없다(PyTorch 재현성 문서)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch00-026",
   "metadata": {},
   "source": [
    "## 문제 7. 예열을 뺀 시간 측정 (코드)\n",
    "\n",
    "`fn`을 `warmup`번 먼저 호출해 버리고, 그다음 `n`번 호출의 **평균 시간**(초)을 돌려주는 `time_per_call(fn, warmup=1, n=5)`를 완성하세요. 시간은 `time.perf_counter()`로 잽니다.\n",
    "\n",
    "<details><summary>힌트</summary>\n",
    "\n",
    "예열 반복이 끝난 **뒤에** 시작 시각을 기록해야 예열 시간이 섞이지 않습니다.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch00-027",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "def time_per_call(fn, warmup=1, n=5):\n",
    "    for _ in range(warmup):\n",
    "        fn()\n",
    "    t0 = time.perf_counter()\n",
    "    for _ in range(n):\n",
    "        fn()\n",
    "    return (time.perf_counter() - t0) / n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch00-028",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "# 가짜 시계: 첫 호출은 3초, 그다음은 1초씩 걸린 것처럼 시간이 흐른다\n",
    "clock, calls = [0.0], []\n",
    "def fake_fn():\n",
    "    calls.append(1)\n",
    "    clock[0] += 3.0 if len(calls) == 1 else 1.0\n",
    "\n",
    "real_clock = time.perf_counter\n",
    "time.perf_counter = lambda: clock[0]\n",
    "try:\n",
    "    s = time_per_call(fake_fn, warmup=1, n=5)\n",
    "finally:\n",
    "    time.perf_counter = real_clock\n",
    "assert len(calls) == 6, f\"호출 횟수가 {len(calls)}번입니다. 예열 1 + 측정 5 = 6번이어야 합니다\"\n",
    "assert s is not None, \"값을 돌려주세요\"\n",
    "hint = {5.0: \"합계를 돌려줬습니다. n으로 나누세요\", 1.6: \"예열 시간이 섞였습니다\"}\n",
    "assert abs(s - 1.0) < 1e-9, hint.get(round(s, 6), f\"평균 {s}: 1.0이어야 합니다\")\n",
    "M = np.random.default_rng(0).random((200, 200))\n",
    "print(f\"200x200 행렬곱 {time_per_call(lambda: M @ M) * 1000:.3f} ms / 통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch00-029",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> 첫 호출은 메모리 할당·캐시·지연 로딩 때문에 느린 경우가 많다(모델 첫 추론이 특히 그렇다). 이것을 평균에 섞으면 전체 시간을 과대 추정한다. 반대로 실제 서비스의 \"첫 응답 시간\"이 중요하면 그것은 따로 잰다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch00-030",
   "metadata": {},
   "source": [
    "## 문제 8. 모델 메모리 어림 (코드)\n",
    "\n",
    "**파라미터**(parameter)는 모델이 학습으로 정하는 숫자(가중치)이고, **자료형**(dtype)은 숫자 하나를 몇 바이트로 저장하는지 정한다. 원고 0-6절의 \"원소 수 × 원소 하나의 바이트 수\"가 모델에도 그대로 쓰인다.\n",
    "\n",
    "파라미터 수와 자료형 이름을 받아 **가중치만** 올리는 데 필요한 메모리를 MB(10진, 1MB = 10⁶바이트)로 돌려주는 `model_mb(n_params, dtype)`를 완성하세요.\n",
    "\n",
    "| dtype | 원소 1개 바이트 |\n",
    "|---|---|\n",
    "| `\"float32\"` | 4 |\n",
    "| `\"float16\"`, `\"bfloat16\"` | 2 |\n",
    "| `\"int8\"` | 1 |\n",
    "\n",
    "모르는 dtype이면 `ValueError`를 내세요."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch00-031",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "BYTES = {\"float32\": 4, \"float16\": 2, \"bfloat16\": 2, \"int8\": 1}\n",
    "\n",
    "def model_mb(n_params, dtype):\n",
    "    if dtype not in BYTES:\n",
    "        raise ValueError(f\"모르는 dtype: {dtype}\")\n",
    "    return n_params * BYTES[dtype] / 1e6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch00-032",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "assert model_mb(5e8, \"float32\") == 2000\n",
    "assert model_mb(5e8, \"bfloat16\") == 1000\n",
    "assert model_mb(1_000_000, \"int8\") == 1\n",
    "try:\n",
    "    model_mb(10, \"float8\")\n",
    "    raise AssertionError(\"모르는 dtype에서 ValueError가 나야 합니다\")\n",
    "except ValueError:\n",
    "    pass\n",
    "t = torch.zeros(1000, 1000, dtype=torch.float16)\n",
    "assert model_mb(t.numel(), \"float16\") == t.element_size() * t.numel() / 1e6\n",
    "print(\"통과\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch00-033",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> 이 계산은 **가중치만**이다. 추론할 때는 중간 계산값(활성값)과 임시 버퍼가 더해진다. 학습할 때는 더 크다. 모든 파라미터를 float32로 학습하는 일반 Adam이라면 기울기(가중치와 같은 크기)와 Adam 상태(가중치의 2배)가 더해져 가중치의 약 4배에 활성값이 추가된다. 혼합 정밀도 학습은 자료형마다 사본이 달라 비율이 바뀐다. VRAM이 모자라면 자료형을 줄이거나(18장 양자화) 배치를 줄인다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch00-034",
   "metadata": {},
   "source": [
    "## 문제 9. 느린 학습 (사례)\n",
    "\n",
    "교재에서 \"GPU로 1에폭 3초\"라고 한 학습 코드를 GPU가 있는 PC에서 그대로 돌렸는데 1에폭에 2분이 걸립니다. 오류는 없습니다. **가장 먼저** 확인할 것을 `q9`에 적으세요.\n",
    "\n",
    "- A. 학습률을 더 크게 바꿔 본다.\n",
    "- B. `torch.cuda.is_available()`과 모델·데이터 텐서의 `.device`를 출력해 실제로 GPU에서 계산하는지 본다.\n",
    "- C. 시드를 바꿔 다시 실행한다.\n",
    "- D. 데이터를 섞지 않도록 바꾼다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch00-035",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "q9 = \"B\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ch00-036",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행만 하세요\n",
    "check(\"q9\", q9, \"df7e70e50215\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch00-037",
   "metadata": {},
   "source": [
    "> **해설**\n",
    ">\n",
    "> 학습률·시드·섞기는 결과(정확도)를 바꿀 뿐 1에폭 시간을 수십 배 바꾸지 않는다. 40배 느리다면 CPU에서 돌고 있을 가능성이 가장 크다: CPU용 torch 설치, 다른 venv 커널, `.to(device)` 결과를 받지 않은 실수 등이다. 원인을 고르기 전에 **측정 가능한 사실부터 출력**하는 습관을 들인다."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ch00-038",
   "metadata": {},
   "source": [
    "## 마무리\n",
    "\n",
    "- [ ] Restart & Run All로 모든 점검 셀이 \"통과\"를 출력한다.\n",
    "- [ ] 문제 2의 `venv 사용 중`이 `True`다(교재용 venv를 쓰는 경우).\n",
    "- [ ] 여러분 PC의 장치(cpu/cuda)와 주요 버전을 메모해 두었다.\n",
    "\n",
    "다음 장(01장 AI의 흐름)부터 선택 기준표를 쌓기 시작한다."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
