diff --git "a/Week12_\341\204\207\341\205\251\341\206\250\341\204\211\341\205\263\341\206\270\341\204\200\341\205\252\341\204\214\341\205\246_\341\204\200\341\205\265\341\206\267\341\204\216\341\205\242\341\204\213\341\205\247\341\206\274.ipynb" "b/Week12_\341\204\207\341\205\251\341\206\250\341\204\211\341\205\263\341\206\270\341\204\200\341\205\252\341\204\214\341\205\246_\341\204\200\341\205\265\341\206\267\341\204\216\341\205\242\341\204\213\341\205\247\341\206\274.ipynb"
new file mode 100644
index 0000000..4eb450f
--- /dev/null
+++ "b/Week12_\341\204\207\341\205\251\341\206\250\341\204\211\341\205\263\341\206\270\341\204\200\341\205\252\341\204\214\341\205\246_\341\204\200\341\205\265\341\206\267\341\204\216\341\205\242\341\204\213\341\205\247\341\206\274.ipynb"
@@ -0,0 +1,2811 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "8Gxy65cu8irm"
+      },
+      "source": [
+        "##**Text generation Experiment**\n",
+        "\n",
+        "- 이번 복습과제에는 GPT-2 모델을 사용한 텍스트 생생을 다룹니다. 🙂\n",
+        "- GPT-2는 약 40GB의 인터넷 텍스트 데이터로 훈련된 모델로 다음 단어 예측(next word prediction)을 목적으로 학습이 되었습니다\n",
+        "- Beam Search, Top-k sampling, Top-p sampling 과 같은 다양한 디코딩 기법들을 실험해보겠습니다."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {
+        "id": "_M2apVV-8cyb"
+      },
+      "outputs": [],
+      "source": [
+        "#reproducability을 위해 해당 코드를 실행해주세요\n",
+        "SEED = 34\n",
+        "#max number of words in output text\n",
+        "MAX_LEN = 70"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 2,
+      "metadata": {
+        "id": "Kd6ZRQmG8gWL"
+      },
+      "outputs": [],
+      "source": [
+        "# 실험할 문장입니다.\n",
+        "input_sequence = \"I don't know about you, but there's only one thing I want to do after a long day of work\""
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 3,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 447,
+          "referenced_widgets": [
+            "2d4f1219ef25408aa0725c0a49b9ea5e",
+            "f31d37c927fd425e996c43e725a663ca",
+            "6b16506a0f8b491a9a0cb64c66773ff6",
+            "abd181c4d3ed4eca9c5269d75775c833",
+            "ac9cad3163ca4f929351a83cbe2edeb4",
+            "5a438f5d61ec44e49989e5612e0c06da",
+            "81c2fbac07ad44ffb311b6ac66743ed7",
+            "89fa32bdca4a48e3ba414feedfcb04a2",
+            "60a4e1d50fd444e1ae57eab72271abca",
+            "4fd5dff2c25a4480a2174ae1d81034f2",
+            "73e5adfbe1534c4190c9b8c91a572086",
+            "2a6b2b09f17f49969b67e4620459bb23",
+            "c9f766dda0da4c0194c0ddcd0cd61919",
+            "52a7a4e16916470294f2e7eb1fffdffc",
+            "efa6f9fc9a3b48b1a420726468e5fd3b",
+            "5e81b02a5622493199f44d098a34d2d4",
+            "80ff4590a7ec4a7eafb72dc173e04e48",
+            "c29b119b2b8343e5b12e80792480ed99",
+            "57e3af88b7fc4ec094429df84d12122d",
+            "26f6ef105a964324a84800b82754bd93",
+            "d700bf4777044b609c302ce42d369e1c",
+            "f04b4cf625dc47f099f648251146b4bf",
+            "705d739638ac44818056709a166bdad1",
+            "c0ab53a39af24f068900f669db515a05",
+            "3b655421119a4d0e945bc4f5e38dab01",
+            "03cc758ab39a4a0b822c14cb46f433b2",
+            "c2f091c1b7bc4a6480388a4c585baf5b",
+            "5d6fbbc06ce049578d1c300767dfc5c6",
+            "21e7522ed55a40ef8d29142acc3d069d",
+            "c0ce81d32c0047968528dc89bbf3580b",
+            "d233c8c5fb8648a0a63aae44f92657a2",
+            "7d2890d7ce574771b28b0e595c8fe232",
+            "09f42b6f43b44205bf9730cd77cda528",
+            "d89a8e0780544add9746bf1ea2e673d9",
+            "3acec24844b34e09a016e64f26eafcf6",
+            "b4603ba94d6346c8b9e39f08d038c3ae",
+            "ab0e43b3c36943a5bd9ccf3f4a3c9ede",
+            "bbbfdacb13dd40c2aa1d6f3fd4c59ef7",
+            "e651f62916f24655b722ed452b1062e4",
+            "198f2dd8e7aa430cb14a09476867c950",
+            "f95cb57979074d0f91bf769d6d37cd90",
+            "5eb218303fb4438c9bb64d4440d030ef",
+            "41aa17ebc83e464c871a506f231eba30",
+            "a4ac57284b044e0a963a0d6c751e1858",
+            "03791febac134be9bcd6b378127fb7a5",
+            "d212d272ab1942a7a875799788da02df",
+            "3b4a076a5e1041388bf285d9e05061d2",
+            "df5b37307e2443d0a263966e1f91133b",
+            "ab66fec2dc584fd1a369bd4aa4c8ee9d",
+            "d0322248bf514595a619b2dbde524697",
+            "59148ba271f147599d5ad1a1a3ca8712",
+            "8d0dc89c154c4fec9d04f5794abd20f3",
+            "35f506c453dc4f0f9e42dae9d2487c7d",
+            "216a04bb3a4848dfaad2920b827b4b6e",
+            "127cffac102a48f9a0fa0ff6f111a5cf",
+            "cca618e303b34611a77bc54261f9c785",
+            "56b0c404027b4d8da66794d29a5f7696",
+            "30e77991e34b462ab4f369c70d6f7ebc",
+            "1c7e8cd2ced64a65807c95407deb0cb9",
+            "130853ac235e4a0a95ad94afa92eab44",
+            "6235c74c67304ad79649955b9bb56815",
+            "5ae64d63f72e4fa199526bbf5fbf20d6",
+            "690bd98f6dc9409e87d4466aed4485f6",
+            "b8646219a56344ef82985203817b6d24",
+            "09d272d68a564dea9537fa87e20247c1",
+            "94d886400a414791bf5ee907ff943def"
+          ]
+        },
+        "id": "pEjO6IVs8gS0",
+        "outputId": "f99695d5-671d-4dc6-9a04-76e1193d0b83"
+      },
+      "outputs": [
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "883036e8c13548dfa9b109e374b969c5",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "tokenizer_config.json:   0%|          | 0.00/26.0 [00:00<?, ?B/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "b00956b240ae473f8e3e6ac0c450ae95",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "vocab.json:   0%|          | 0.00/1.04M [00:00<?, ?B/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "eb40115997da436b8abd8350fea825a9",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "merges.txt:   0%|          | 0.00/456k [00:00<?, ?B/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "eb41bc85f0e5468a9680142747e652a8",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "tokenizer.json:   0%|          | 0.00/1.36M [00:00<?, ?B/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "e093c0ee1d214eacb9af60aee6337989",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "config.json:   0%|          | 0.00/666 [00:00<?, ?B/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "6aec5b9cb9a941c2947b25805c21f509",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "model.safetensors:   0%|          | 0.00/3.25G [00:00<?, ?B/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "All PyTorch model weights were used when initializing TFGPT2LMHeadModel.\n",
+            "\n",
+            "All the weights of TFGPT2LMHeadModel were initialized from the PyTorch model.\n",
+            "If your task is similar to the task the model of the checkpoint was trained on, you can already use TFGPT2LMHeadModel for predictions without further training.\n"
+          ]
+        }
+      ],
+      "source": [
+        "# transformers을 가져와서 사용해봅시다\n",
+        "from transformers import TFGPT2LMHeadModel, GPT2Tokenizer\n",
+        "\n",
+        "# pretrained large GPT2 tokenizer 와  GPT2 model를 가져와주세요.\n",
+        "tokenizer = GPT2Tokenizer.from_pretrained(\"gpt2-large\")\n",
+        "GPT2 = TFGPT2LMHeadModel.from_pretrained(\"gpt2-large\", pad_token_id=tokenizer.eos_token_id)\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 4,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "QI2_C2gw8gPq",
+        "outputId": "5e59b089-f433-4ecd-d4f1-417469264a9b"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Model: \"tfgpt2lm_head_model\"\n",
+            "_________________________________________________________________\n",
+            " Layer (type)                Output Shape              Param #   \n",
+            "=================================================================\n",
+            " transformer (TFGPT2MainLay  multiple                  774030080 \n",
+            " er)                                                             \n",
+            "                                                                 \n",
+            "=================================================================\n",
+            "Total params: 774030080 (2.88 GB)\n",
+            "Trainable params: 774030080 (2.88 GB)\n",
+            "Non-trainable params: 0 (0.00 Byte)\n",
+            "_________________________________________________________________\n"
+          ]
+        }
+      ],
+      "source": [
+        "# model parameters을 확인해 봅시다.\n",
+        "GPT2.summary()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 5,
+      "metadata": {
+        "id": "cPFXwobg8gMJ"
+      },
+      "outputs": [],
+      "source": [
+        "#아래 코드를 실행해주세요-\n",
+        "import tensorflow as tf\n",
+        "tf.random.set_seed(SEED)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "zsX-xn93-tUP"
+      },
+      "source": [
+        "### **Greedy-Search**\n",
+        "- Greedy Search 에서는 각 시점마다 가장 확률이 높은 단어를 다음 단어로 선택합니다.\n",
+        "- 즉, 다음 단어는 아래와 같이 업데이트됩니다:\n",
+        "\n",
+        "$ wt=argmax wP(w|w1:t−1) $  \n",
+        "\n",
+        "> 즉, 각 타임스텝 𝑡마다 조건부 확률이 가장 높은 단어를 선택하는 것!\n",
+        "\n",
+        "\n",
+        "- 이 단순한 접근방식이 어떤 성능 차이를 보이는지 살펴봅시다."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 13,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "ig-oWtIA8gIq",
+        "outputId": "0ce6a21d-f716-458a-9354-5be570396653"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Output:\n",
+            "----------------------------------------------------------------------------------------------------\n",
+            "I don't know about you, but there's only one thing I want to do after a long day of work: go to the gym.\n",
+            "\n",
+            "I'm not talking about the gym that's right next to my house. I'm talking about\n"
+          ]
+        }
+      ],
+      "source": [
+        "context = \"I don't know about you, but there's only one thing I want to do after a long day of work\"\n",
+        "\n",
+        "# context를 encoder해주세요\n",
+        "input_ids = tokenizer.encode(context, return_tensors=\"pt\")\n",
+        "\n",
+        "# 텍스트 생성하기, 이때 output length가 (context length 포함) 50이 될 때까지\n",
+        "greedy_output = GPT2.generate(input_ids, max_length=50)\n",
+        "\n",
+        "# output sequences 출력하기\n",
+        "print(\"Output:\\n\" + 100 * '-')\n",
+        "print(tokenizer.decode(greedy_output[0], skip_special_tokens = True))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "gVj1neC__f2N"
+      },
+      "source": [
+        "💡**위 Greedy Search 식과 코드 결과를 보고 고려되는 주요 문제점을 해당 셀을 풀고 설명해주세요.**\n",
+        "\n",
+        "\n",
+        "---\n",
+        "\n",
+        "\n",
+        "- 지역 최적화(Local Optimum): 매 스텝 최대 확률만을 따르다 보니, 전체 문맥을 고려한 더 좋은 시퀀스를 놓치기 쉬움.\n",
+        "- 반복성·단조로움 : 동일한 확률 상위 토큰이 계속 선택되어, 텍스트가 획일적이고 예측 가능해짐."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "3EC0shCGAAQq"
+      },
+      "source": [
+        "### **Beam Search + N-Gram Penalty**\n",
+        "- Beam Search는 기본적으로 Greedy Search와 유사하지만, 모델이 각 시점에서 여러 개(num_beams)의 후보 경로를 동시에 추적한다는 점이 다릅니다\n",
+        " > 즉, 모델이 여러 대안을 비교하면서 텍스트를 생성할 수 있다는 점!\n",
+        "\n",
+        "\n",
+        "- 또한, n-gram 반복을 방지하기 위한 패널티도 적용할 수 있습니다.예를 들어 `no_repeat_ngram_size = 2`로 설정하면\n",
+        "동일한 2-그램이 두 번 등장하지 않도록 제한됩니다.\n",
+        "\n",
+        "- 그리고 `num_return_sequences = 5` 로 설정하면\n",
+        "5개의 beam 결과를 모두 출력하여 비교해볼 수 있습니다."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 14,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "l6OrEzA684Np",
+        "outputId": "392c9796-8cdb-4c9d-9f5a-32eae3462597"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "\n",
+            "Output:\n",
+            "----------------------------------------------------------------------------------------------------\n",
+            "0: I don't know about you, but there's only one thing I want to do after a long day of work, and that's to go home and watch a movie.\"\n",
+            "\n",
+            "\"I don't know about you, but there's only one\n",
+            "1: I don't know about you, but there's only one thing I want to do after a long day of work, and that's to go home and watch a movie.\"\n",
+            "\n",
+            "\"I don't know about you, but I don't want\n",
+            "2: I don't know about you, but there's only one thing I want to do after a long day of work, and that's to go home and watch a movie.\"\n",
+            "\n",
+            "\"I don't know about you, but I want to go\n",
+            "3: I don't know about you, but there's only one thing I want to do after a long day of work, and that's to go home and watch a movie.\"\n",
+            "\n",
+            "\"I don't know about you, but I'd like to\n",
+            "4: I don't know about you, but there's only one thing I want to do after a long day of work, and that's to go home and watch a movie.\"\n",
+            "\n",
+            "\"I don't know about you, but I don't think\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Beam Search를 사용하려면,단순히 generate 함수의 몇몇 파라미터만 변경하면 됩니다.\n",
+        "# num_beans를 설정해서 beam search decoding을 실행해주세요\n",
+        "beam_outputs = GPT2.generate(\n",
+        "    input_ids, \n",
+        "    max_length=50, \n",
+        "    num_beams=5, \n",
+        "    num_return_sequences=5, \n",
+        "    early_stopping=True\n",
+        ")\n",
+        "\n",
+        "\n",
+        "print('')\n",
+        "print(\"Output:\\n\" + 100 * '-')\n",
+        "\n",
+        "# output sequences 출력하기\n",
+        "for i, beam_output in enumerate(beam_outputs):\n",
+        "      print(\"{}: {}\".format(i, tokenizer.decode(beam_output, skip_special_tokens=True)))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "_VhLZdJlBVZk"
+      },
+      "source": [
+        "💡**아래 그래프는 Beam Search의 결과와 실제 인간의 말하기 방식 사이의 차이를 보여줍니다. 위 Beam Search 코드 결과와 아래 그래프를  보고 고려되는 주요 문제점을 해당 셀을 풀고 설명해주세요. (기재된 논문에서 힌트를 찾을 수 있습니다.)**\n",
+        "\n",
+        "\n",
+        "---\n",
+        "\n",
+        "\n",
+        "-  Beam Search는 매 timestep마다 현재까지 누적 확률이 높은 상위 K개의 후보 집합만을 유지하며 다음 토큰을 선택하기 때문에, 확률이 낮아 보이지만 뒤쪽 문맥을 고려하면 더 자연스럽게 이어질 수 있는 토큰을 놓칠 가능성이 크다."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "aOBGUk2aAwQ-"
+      },
+      "source": [
+        "![image.png](data:image/png;base64,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)\n",
+        "\n",
+        "[출처] The Curious Case of Neural Text Degeneration, arXiv:1904.09751 (cs)\n",
+        "https://arxiv.org/abs/1904.09751"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "BcDagIp1BvFA"
+      },
+      "source": [
+        "### **Basic Sampling**\n",
+        "- 이 방식은 가장 확률이 높은 문장을 찾는 경로를 고집하지 않고, 각 시점에서 조건부 확률 분포에 따라 무작위로 다음 단어를 선택합니다.\n",
+        "\n",
+        "$w t​ ∼P(w∣w 1:t−1)$\n",
+        "- 하지만 이렇게 무작위성이 추가되면, 생성된 문장이 일관성이 떨어지고 혼란스러워질 수 있습니다.\n",
+        "- 그래서 무작위성을 제어하기 위해 temperature 파라미터를 도입할 수 있습니다. 이 파라미터는 확률이 높은 단어의 선택 가능성을 높이고, 확률이 낮은 단어는 선택될 가능성을 줄여줍니다."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 15,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "z6pXSH2RBuz8",
+        "outputId": "a4b7f4f2-ca61-4714-a194-2dce3b483ad0"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Output:\n",
+            "----------------------------------------------------------------------------------------------------\n",
+            "I don't know about you, but there's only one thing I want to do after a long day of work. I want to take a nice nap.\"\n",
+            "\n",
+            "I was a bit surprised. Now I was to have her fall asleep on me\n"
+          ]
+        }
+      ],
+      "source": [
+        "# 샘플링을 구현하려면 do_sample = True만 설정하면 됩니다.\n",
+        "# temperature을 설정해주세요.\n",
+        "# 이때 top_k = 0으로 설정해주세요.\n",
+        "sample_output = GPT2.generate(\n",
+        "    input_ids,\n",
+        "    max_length=50,\n",
+        "    do_sample=True,\n",
+        "    temperature=0.7,\n",
+        "    top_k=0\n",
+        ")\n",
+        "\n",
+        "# output sequences 출력하기\n",
+        "print(\"Output:\\n\" + 100 * '-')\n",
+        "print(tokenizer.decode(sample_output[0], skip_special_tokens = True))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "8g2RrY7PFmjJ"
+      },
+      "source": [
+        "💡**temperature 파라미터가 어떤 매커니즘으로  무작위성을 제어하는지  해당 셀을 풀고 설명해주세요.**\n",
+        "\n",
+        "\n",
+        "---\n",
+        "\n",
+        "- Temperature는 로짓(logits)에 대한 스케일(scale)을 조정하여,\n",
+        "낮게 설정(T<1)하면 확률 분포가 더욱 뾰족(peaky) 해져서, 무작위성이 줄어들고, 높게 설정(T>1)하면 확률 분포가 평탄(flat) 해져서, 무작위성이 증가한다. 따라서 T값을 조정함으로써 샘플링 시의 불확실성을 조절할 수 있다.\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "RzmrRsA8CmYs"
+      },
+      "source": [
+        "### **Top-k Sampling**\n",
+        "- Top-K 샘플링에서는 다음 단어 후보 중 확률이 가장 높은 상위 K개 단어만 선택하고,\n",
+        "전체 probability mass을 이 K개의 단어에만 분배합니다.\n",
+        "\n",
+        "> 즉, 확률이 높은 단어의 선택 확률을 높이고, 낮은 단어의 확률을 줄이는 방식이 아니라,아예 확률이 낮은 단어들을 완전히 제거하는 방식!"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 16,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "WA-og6IeD1BZ",
+        "outputId": "e279dbbc-c4e1-411a-ca49-8c0952000b61"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Output:\n",
+            "----------------------------------------------------------------------------------------------------\n",
+            "I don't know about you, but there's only one thing I want to do after a long day of work is to make more money! And in fact that's pretty much what happened just two weeks ago when I made the following calculation.\n",
+            " ...\n"
+          ]
+        }
+      ],
+      "source": [
+        "# top_k 값을 설정해서, 조건부 확률 분포에서 고려할 상위 단어 개수(K)를 지정해주세요!\n",
+        "sample_output = GPT2.generate(\n",
+        "    input_ids,\n",
+        "    max_length=50,\n",
+        "    do_sample=True,\n",
+        "    top_k=50\n",
+        ")\n",
+        "\n",
+        "# output sequences 출력하기\n",
+        "print(\"Output:\\n\" + 100 * '-')\n",
+        "print(tokenizer.decode(sample_output[0], skip_special_tokens = True), '...')"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "2CgUegJOAw6h"
+      },
+      "source": [
+        "### **Top-P Sampling(Nucleus Sampling)**\n",
+        "- Top-K 샘플링은 이전의 random sampling보다 더 일관된 텍스트를 생성하는 것으로 보입니다. 하지만 이보다 더나은 방법으로 Top-p sampling이 있습니다.\n",
+        "- Top-P 샘플링은 Top-K와 유사하지만,가장 확률이 높은 상위 K개 단어를 고르는 대신,누적 확률이 P 이상이 되는 최소한의 단어 집합을 선택합니다 그리고 전체 probability mass는 이 단어 집합에 재분배됩니다.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 18,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "GEhy8PgbAr2f",
+        "outputId": "aac06a08-21b7-4e78-a231-a4e29709b343"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Output:\n",
+            "----------------------------------------------------------------------------------------------------\n",
+            "I don't know about you, but there's only one thing I want to do after a long day of work.\n",
+            "\n",
+            "I want to eat a big meal and relax on the couch.\n",
+            "\n",
+            "I want to read a good book and just ...\n"
+          ]
+        }
+      ],
+      "source": [
+        "# top_p 파라미터를 통해 only from 80% most likely words 만  sample 해주세요.\n",
+        "sample_output = GPT2.generate(\n",
+        "    input_ids,\n",
+        "    max_length=50,\n",
+        "    do_sample=True,\n",
+        "    top_p=0.8\n",
+        ")\n",
+        "\n",
+        "# output sequences 출력하기\n",
+        "print(\"Output:\\n\" + 100 * '-')\n",
+        "print(tokenizer.decode(sample_output[0], skip_special_tokens = True), '...')"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "heGKePrAE46H"
+      },
+      "source": [
+        "### **Top-K + Top-P sampling**\n",
+        "- 둘을 동시에 사용하면, 확률이 매우 낮은 단어(이상한 단어)가 나올 가능성을 줄이면서도, 선택되는 단어 집합의 크기는 유동적으로 유지할 수 있습니다."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 17,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "Q8-CnW76E3FI",
+        "outputId": "8d547cbd-53ac-4710-d81b-6162649eddcf"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Output:\n",
+            "----------------------------------------------------------------------------------------------------\n",
+            "0: I don't know about you, but there's only one thing I want to do after a long day of work: go to the beach. And I don't mean just a little bit of sand, I mean a whole lot of sand. I want to be out in the ocean. I want to go to the beach, and I want to get all of my sunburned out.\n",
+            "\n",
+            "So I bought a beach umbrella. It's made from a rubberized fabric that's easy to wash, and it's the perfect size for me. It's about the size of my hand, and I can't really get it all the way around to the front. I'm not sure why...\n",
+            "\n",
+            "1: I don't know about you, but there's only one thing I want to do after a long day of work: sit down and watch a movie. I've got a few favorites.\n",
+            "\n",
+            "1. The Good, the Bad, and the Ugly (1942)\n",
+            "\n",
+            "The Good, the Bad, and the Ugly is one of the most famous films of all time, and it's also one of the most underrated. It's a film about a group of misfits who are sent to a war-torn village in order to help out the local population. The Good, the Bad, and the Ugly is a film about the human condition, and it's also about...\n",
+            "\n",
+            "2: I don't know about you, but there's only one thing I want to do after a long day of work: go to a movie. I'm a big fan of the '80s, and the '90s, and the 2000s, and the 2010s. I'm a huge fan of the '70s, and the '80s, and the '90s.\n",
+            "\n",
+            "You know, I just watched a documentary on the '90s. I don't know what it's called, but it's about the '90s. It's called \"The Rise of the New Millennium.\" It's a great documentary. I just want to see a movie that's about...\n",
+            "\n",
+            "3: I don't know about you, but there's only one thing I want to do after a long day of work, and that's to watch the game on TV. I'm not the only one. I know a lot of people that watch the game, and they're all like, 'Man, I don't want to do this anymore. I don't want to do this anymore.' And I'm like, 'Well, that's not gonna happen. I'm gonna do this.'\"\n",
+            "\n",
+            "Brock's \"The Biggest Loser\" was canceled after the show's fourth season.\n",
+            "\n",
+            "Brock's final season of \"The Biggest Loser\" was cut short after the...\n",
+            "\n",
+            "4: I don't know about you, but there's only one thing I want to do after a long day of work, and that's to sit back and relax.\"\n",
+            "\n",
+            "\"Well, I guess that's a good thing,\" said Weiss, nodding. \"I'm glad you're here.\"\n",
+            "\n",
+            "\"Yeah, I know. I'm glad you're here.\"\n",
+            "\n",
+            "\"Yeah, I'm glad you're here.\"\n",
+            "\n",
+            "\"Yeah, I'm glad you're here.\"\n",
+            "\n",
+            "\"Yeah, I'm glad you're here.\"\n",
+            "\n",
+            "\"Yeah, I'm glad you're here.\"\n",
+            "\n",
+            "\"Yeah, I'm glad you're here.\"\n",
+            "\n",
+            "\"Yeah, I...\n",
+            "\n"
+          ]
+        }
+      ],
+      "source": [
+        "# top_k와 top_p에 값을 지정하면 되고, temperature 파라미터도 함께 사용할 수 있습니다.\n",
+        "# 아래 코드를 완성해주세요.\n",
+        "# 이때 max_length= 2*MAX_LEN 으로 설정해주세요\n",
+        "sample_outputs = GPT2.generate(\n",
+        "    input_ids,\n",
+        "    max_length=2 * MAX_LEN,\n",
+        "    do_sample=True,\n",
+        "    top_k=50,\n",
+        "    top_p=0.8,\n",
+        "    temperature=0.7,\n",
+        "    num_return_sequences=5\n",
+        ")\n",
+        "# output sequences 출력하기\n",
+        "print(\"Output:\\n\" + 100 * '-')\n",
+        "for i, sample_output in enumerate(sample_outputs):\n",
+        "    print(\"{}: {}...\".format(i, tokenizer.decode(sample_output, skip_special_tokens = True)))\n",
+        "    print('')"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "s_TeJ5zXF6Ra"
+      },
+      "source": [
+        "💡**Top-k와 Top-p의 방식의 차이에 대해 설명해주세요**\n",
+        "\n",
+        "\n",
+        "---\n",
+        "## Top-k\n",
+        "\n",
+        "- 항상 확률 상위 *k*개의 토큰만 남기고 샘플링한다\n",
+        "\n",
+        "- **특징**  \n",
+        "  - 후보 집합 크기가 **고정**되어 있어, 계산량을 예측하기 쉽다  \n",
+        "  - 그러나 확률이 낮더라도 상위 *k* 안에 들어가 있으면 샘플링 대상이 되므로, 문맥에 어울리지 않는 무작위성이 발생할 수 있다\n",
+        "\n",
+        "---\n",
+        "\n",
+        "## Top-p \n",
+        "\n",
+        "- 조건부 확률 분포를 내림차순으로 정렬한 뒤, 누적 확률이 *p*가 될 때까지 상위 토큰들을 모아 그 안에서 샘플링한다\n",
+        "\n",
+        "- **특징**  \n",
+        "  - 후보 집합 크기가 문맥에 따라 **동적으로 변동**한다  \n",
+        "  - 문맥에 알맞은 토큰들만 고려하여 무작위성을 조절하기 때문에, 더 자연스럽고 안정적인 출력을 얻을 수 있다\n"
+      ]
+    }
+  ],
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "codemirror_mode": {
+        "name": "ipython",
+        "version": 3
+      },
+      "file_extension": ".py",
+      "mimetype": "text/x-python",
+      "name": "python",
+      "nbconvert_exporter": "python",
+      "pygments_lexer": "ipython3",
+      "version": "3.12.2"
+    },
+    "widgets": {
+      "application/vnd.jupyter.widget-state+json": {
+        "03791febac134be9bcd6b378127fb7a5": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_d212d272ab1942a7a875799788da02df",
+              "IPY_MODEL_3b4a076a5e1041388bf285d9e05061d2",
+              "IPY_MODEL_df5b37307e2443d0a263966e1f91133b"
+            ],
+            "layout": "IPY_MODEL_ab66fec2dc584fd1a369bd4aa4c8ee9d"
+          }
+        },
+        "03cc758ab39a4a0b822c14cb46f433b2": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_7d2890d7ce574771b28b0e595c8fe232",
+            "placeholder": "​",
+            "style": "IPY_MODEL_09f42b6f43b44205bf9730cd77cda528",
+            "value": " 456k/456k [00:00&lt;00:00, 20.9MB/s]"
+          }
+        },
+        "09d272d68a564dea9537fa87e20247c1": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "09f42b6f43b44205bf9730cd77cda528": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "127cffac102a48f9a0fa0ff6f111a5cf": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "130853ac235e4a0a95ad94afa92eab44": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "198f2dd8e7aa430cb14a09476867c950": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "1c7e8cd2ced64a65807c95407deb0cb9": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_09d272d68a564dea9537fa87e20247c1",
+            "placeholder": "​",
+            "style": "IPY_MODEL_94d886400a414791bf5ee907ff943def",
+            "value": " 3.25G/3.25G [00:44&lt;00:00, 35.2MB/s]"
+          }
+        },
+        "216a04bb3a4848dfaad2920b827b4b6e": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "21e7522ed55a40ef8d29142acc3d069d": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "26f6ef105a964324a84800b82754bd93": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "2a6b2b09f17f49969b67e4620459bb23": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_c9f766dda0da4c0194c0ddcd0cd61919",
+              "IPY_MODEL_52a7a4e16916470294f2e7eb1fffdffc",
+              "IPY_MODEL_efa6f9fc9a3b48b1a420726468e5fd3b"
+            ],
+            "layout": "IPY_MODEL_5e81b02a5622493199f44d098a34d2d4"
+          }
+        },
+        "2d4f1219ef25408aa0725c0a49b9ea5e": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_f31d37c927fd425e996c43e725a663ca",
+              "IPY_MODEL_6b16506a0f8b491a9a0cb64c66773ff6",
+              "IPY_MODEL_abd181c4d3ed4eca9c5269d75775c833"
+            ],
+            "layout": "IPY_MODEL_ac9cad3163ca4f929351a83cbe2edeb4"
+          }
+        },
+        "30e77991e34b462ab4f369c70d6f7ebc": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_690bd98f6dc9409e87d4466aed4485f6",
+            "max": 3247159078,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_b8646219a56344ef82985203817b6d24",
+            "value": 3247159078
+          }
+        },
+        "35f506c453dc4f0f9e42dae9d2487c7d": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "3acec24844b34e09a016e64f26eafcf6": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_e651f62916f24655b722ed452b1062e4",
+            "placeholder": "​",
+            "style": "IPY_MODEL_198f2dd8e7aa430cb14a09476867c950",
+            "value": "tokenizer.json: 100%"
+          }
+        },
+        "3b4a076a5e1041388bf285d9e05061d2": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_8d0dc89c154c4fec9d04f5794abd20f3",
+            "max": 666,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_35f506c453dc4f0f9e42dae9d2487c7d",
+            "value": 666
+          }
+        },
+        "3b655421119a4d0e945bc4f5e38dab01": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_c0ce81d32c0047968528dc89bbf3580b",
+            "max": 456318,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_d233c8c5fb8648a0a63aae44f92657a2",
+            "value": 456318
+          }
+        },
+        "41aa17ebc83e464c871a506f231eba30": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "4fd5dff2c25a4480a2174ae1d81034f2": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "52a7a4e16916470294f2e7eb1fffdffc": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_57e3af88b7fc4ec094429df84d12122d",
+            "max": 1042301,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_26f6ef105a964324a84800b82754bd93",
+            "value": 1042301
+          }
+        },
+        "56b0c404027b4d8da66794d29a5f7696": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_6235c74c67304ad79649955b9bb56815",
+            "placeholder": "​",
+            "style": "IPY_MODEL_5ae64d63f72e4fa199526bbf5fbf20d6",
+            "value": "model.safetensors: 100%"
+          }
+        },
+        "57e3af88b7fc4ec094429df84d12122d": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "59148ba271f147599d5ad1a1a3ca8712": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "5a438f5d61ec44e49989e5612e0c06da": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "5ae64d63f72e4fa199526bbf5fbf20d6": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "5d6fbbc06ce049578d1c300767dfc5c6": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "5e81b02a5622493199f44d098a34d2d4": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "5eb218303fb4438c9bb64d4440d030ef": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "60a4e1d50fd444e1ae57eab72271abca": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "6235c74c67304ad79649955b9bb56815": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "690bd98f6dc9409e87d4466aed4485f6": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "6b16506a0f8b491a9a0cb64c66773ff6": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_89fa32bdca4a48e3ba414feedfcb04a2",
+            "max": 26,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_60a4e1d50fd444e1ae57eab72271abca",
+            "value": 26
+          }
+        },
+        "705d739638ac44818056709a166bdad1": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_c0ab53a39af24f068900f669db515a05",
+              "IPY_MODEL_3b655421119a4d0e945bc4f5e38dab01",
+              "IPY_MODEL_03cc758ab39a4a0b822c14cb46f433b2"
+            ],
+            "layout": "IPY_MODEL_c2f091c1b7bc4a6480388a4c585baf5b"
+          }
+        },
+        "73e5adfbe1534c4190c9b8c91a572086": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "7d2890d7ce574771b28b0e595c8fe232": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "80ff4590a7ec4a7eafb72dc173e04e48": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "81c2fbac07ad44ffb311b6ac66743ed7": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "89fa32bdca4a48e3ba414feedfcb04a2": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "8d0dc89c154c4fec9d04f5794abd20f3": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "94d886400a414791bf5ee907ff943def": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "a4ac57284b044e0a963a0d6c751e1858": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "ab0e43b3c36943a5bd9ccf3f4a3c9ede": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_41aa17ebc83e464c871a506f231eba30",
+            "placeholder": "​",
+            "style": "IPY_MODEL_a4ac57284b044e0a963a0d6c751e1858",
+            "value": " 1.36M/1.36M [00:00&lt;00:00, 34.4MB/s]"
+          }
+        },
+        "ab66fec2dc584fd1a369bd4aa4c8ee9d": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "abd181c4d3ed4eca9c5269d75775c833": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_4fd5dff2c25a4480a2174ae1d81034f2",
+            "placeholder": "​",
+            "style": "IPY_MODEL_73e5adfbe1534c4190c9b8c91a572086",
+            "value": " 26.0/26.0 [00:00&lt;00:00, 1.16kB/s]"
+          }
+        },
+        "ac9cad3163ca4f929351a83cbe2edeb4": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "b4603ba94d6346c8b9e39f08d038c3ae": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_f95cb57979074d0f91bf769d6d37cd90",
+            "max": 1355256,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_5eb218303fb4438c9bb64d4440d030ef",
+            "value": 1355256
+          }
+        },
+        "b8646219a56344ef82985203817b6d24": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "bbbfdacb13dd40c2aa1d6f3fd4c59ef7": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "c0ab53a39af24f068900f669db515a05": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_5d6fbbc06ce049578d1c300767dfc5c6",
+            "placeholder": "​",
+            "style": "IPY_MODEL_21e7522ed55a40ef8d29142acc3d069d",
+            "value": "merges.txt: 100%"
+          }
+        },
+        "c0ce81d32c0047968528dc89bbf3580b": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "c29b119b2b8343e5b12e80792480ed99": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "c2f091c1b7bc4a6480388a4c585baf5b": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "c9f766dda0da4c0194c0ddcd0cd61919": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_80ff4590a7ec4a7eafb72dc173e04e48",
+            "placeholder": "​",
+            "style": "IPY_MODEL_c29b119b2b8343e5b12e80792480ed99",
+            "value": "vocab.json: 100%"
+          }
+        },
+        "cca618e303b34611a77bc54261f9c785": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_56b0c404027b4d8da66794d29a5f7696",
+              "IPY_MODEL_30e77991e34b462ab4f369c70d6f7ebc",
+              "IPY_MODEL_1c7e8cd2ced64a65807c95407deb0cb9"
+            ],
+            "layout": "IPY_MODEL_130853ac235e4a0a95ad94afa92eab44"
+          }
+        },
+        "d0322248bf514595a619b2dbde524697": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "d212d272ab1942a7a875799788da02df": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_d0322248bf514595a619b2dbde524697",
+            "placeholder": "​",
+            "style": "IPY_MODEL_59148ba271f147599d5ad1a1a3ca8712",
+            "value": "config.json: 100%"
+          }
+        },
+        "d233c8c5fb8648a0a63aae44f92657a2": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "d700bf4777044b609c302ce42d369e1c": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "d89a8e0780544add9746bf1ea2e673d9": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_3acec24844b34e09a016e64f26eafcf6",
+              "IPY_MODEL_b4603ba94d6346c8b9e39f08d038c3ae",
+              "IPY_MODEL_ab0e43b3c36943a5bd9ccf3f4a3c9ede"
+            ],
+            "layout": "IPY_MODEL_bbbfdacb13dd40c2aa1d6f3fd4c59ef7"
+          }
+        },
+        "df5b37307e2443d0a263966e1f91133b": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_216a04bb3a4848dfaad2920b827b4b6e",
+            "placeholder": "​",
+            "style": "IPY_MODEL_127cffac102a48f9a0fa0ff6f111a5cf",
+            "value": " 666/666 [00:00&lt;00:00, 67.1kB/s]"
+          }
+        },
+        "e651f62916f24655b722ed452b1062e4": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "efa6f9fc9a3b48b1a420726468e5fd3b": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_d700bf4777044b609c302ce42d369e1c",
+            "placeholder": "​",
+            "style": "IPY_MODEL_f04b4cf625dc47f099f648251146b4bf",
+            "value": " 1.04M/1.04M [00:00&lt;00:00, 12.3MB/s]"
+          }
+        },
+        "f04b4cf625dc47f099f648251146b4bf": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "f31d37c927fd425e996c43e725a663ca": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_5a438f5d61ec44e49989e5612e0c06da",
+            "placeholder": "​",
+            "style": "IPY_MODEL_81c2fbac07ad44ffb311b6ac66743ed7",
+            "value": "tokenizer_config.json: 100%"
+          }
+        },
+        "f95cb57979074d0f91bf769d6d37cd90": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        }
+      }
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}
diff --git a/[Week 12].pdf b/[Week 12].pdf
new file mode 100644
index 0000000..d599794
Binary files /dev/null and b/[Week 12].pdf differ
diff --git a/wk12.ipynb b/wk12.ipynb
new file mode 100644
index 0000000..ace2cf4
--- /dev/null
+++ b/wk12.ipynb
@@ -0,0 +1,1129 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x400 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "%matplotlib inline\n",
+    "import math\n",
+    "import torch\n",
+    "from torch import nn\n",
+    "from matplotlib import pyplot as plt\n",
+    "\n",
+    "class PositionalEncoding(nn.Module):\n",
+    "    def __init__(self, d_model, max_len, dropout=0.1):\n",
+    "        super().__init__()\n",
+    "        self.dropout = nn.Dropout(p=dropout)\n",
+    "        position = torch.arange(max_len).unsqueeze(1)  # (max_len,1)\n",
+    "        div_term = torch.exp(\n",
+    "            torch.arange(0, d_model, 2) * (-math.log(10000.0) / d_model)\n",
+    "        )  # (d_model/2,)\n",
+    "\n",
+    "        pe = torch.zeros(max_len, 1, d_model)         # (max_len,1,d_model)\n",
+    "        pe[:, 0, 0::2] = torch.sin(position * div_term)\n",
+    "        pe[:, 0, 1::2] = torch.cos(position * div_term)\n",
+    "        self.register_buffer(\"pe\", pe)\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = x + self.pe[: x.size(0)]\n",
+    "        return self.dropout(x)\n",
+    "\n",
+    "# 인스턴스 생성\n",
+    "encoding = PositionalEncoding(d_model=128, max_len=50)\n",
+    "\n",
+    "# 그래디언트 분리 → CPU 이동 → squeeze → 파이썬 리스트 변환\n",
+    "arr = encoding.pe.detach().cpu().squeeze(1).tolist()  # shape: [50][128] 리스트\n",
+    "\n",
+    "# 그리기\n",
+    "plt.figure(figsize=(8, 4))\n",
+    "plt.pcolormesh(arr, cmap=\"RdBu\")\n",
+    "plt.xlabel(\"Embedding Dimension\")\n",
+    "plt.xlim((0, 128))\n",
+    "plt.ylabel(\"Position\")\n",
+    "plt.colorbar(label=\"Encoding value\")\n",
+    "plt.title(\"Positional Encoding Heatmap\")\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[38;5;3m⚠ As of spaCy v3.0, shortcuts like 'de' are deprecated. Please use the\n",
+      "full pipeline package name 'de_core_news_sm' instead.\u001b[0m\n",
+      "Collecting de-core-news-sm==3.8.0\n",
+      "  Using cached https://github.com/explosion/spacy-models/releases/download/de_core_news_sm-3.8.0/de_core_news_sm-3.8.0-py3-none-any.whl (14.6 MB)\n",
+      "Installing collected packages: de-core-news-sm\n",
+      "Successfully installed de-core-news-sm-3.8.0\n",
+      "\u001b[38;5;2m✔ Download and installation successful\u001b[0m\n",
+      "You can now load the package via spacy.load('de_core_news_sm')\n",
+      "\u001b[38;5;3m⚠ As of spaCy v3.0, shortcuts like 'en' are deprecated. Please use the\n",
+      "full pipeline package name 'en_core_web_sm' instead.\u001b[0m\n",
+      "Collecting en-core-web-sm==3.8.0\n",
+      "  Using cached https://github.com/explosion/spacy-models/releases/download/en_core_web_sm-3.8.0/en_core_web_sm-3.8.0-py3-none-any.whl (12.8 MB)\n",
+      "Installing collected packages: en-core-web-sm\n",
+      "Successfully installed en-core-web-sm-3.8.0\n",
+      "\u001b[38;5;2m✔ Download and installation successful\u001b[0m\n",
+      "You can now load the package via spacy.load('en_core_web_sm')\n"
+     ]
+    }
+   ],
+   "source": [
+    "!python -m spacy download de\n",
+    "!python -m spacy download en"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "German vocab size: 19214\n",
+      "English vocab size: 10837\n"
+     ]
+    }
+   ],
+   "source": [
+    "import requests\n",
+    "import gzip\n",
+    "import io\n",
+    "from torchtext.data.utils import get_tokenizer\n",
+    "from torchtext.vocab import build_vocab_from_iterator\n",
+    "\n",
+    "# 1) 올바른 raw URL\n",
+    "URL_DE = \"https://raw.githubusercontent.com/multi30k/dataset/master/data/task1/raw/train.de.gz\"\n",
+    "URL_EN = \"https://raw.githubusercontent.com/multi30k/dataset/master/data/task1/raw/train.en.gz\"\n",
+    "\n",
+    "def download_and_read_gz(url):\n",
+    "    resp = requests.get(url)\n",
+    "    resp.raise_for_status()\n",
+    "    # 메모리 상에서 gzip 해제\n",
+    "    with gzip.GzipFile(fileobj=io.BytesIO(resp.content)) as gz:\n",
+    "        return [line.decode(\"utf-8\").strip() for line in gz]\n",
+    "\n",
+    "# 2) 독일어·영어 문장 리스트 로드\n",
+    "de_sentences = download_and_read_gz(URL_DE)\n",
+    "en_sentences = download_and_read_gz(URL_EN)\n",
+    "raw_train = list(zip(de_sentences, en_sentences))  # [(de, en), ...]\n",
+    "\n",
+    "# 3) 토크나이저·특수토큰 세팅\n",
+    "SRC, TGT = \"de\", \"en\"\n",
+    "UNK_IDX = 0\n",
+    "specials = [\"<unk>\", \"<pad>\", \"<bos>\", \"<eos>\"]\n",
+    "tokenizer = {\n",
+    "    SRC: get_tokenizer(\"spacy\", language=\"de_core_news_sm\"),\n",
+    "    TGT: get_tokenizer(\"spacy\", language=\"en_core_web_sm\"),\n",
+    "}\n",
+    "\n",
+    "# 4) 토큰 제너레이터\n",
+    "def generate_tokens(data, lang):\n",
+    "    idx = 0 if lang == SRC else 1\n",
+    "    for src, tgt in data:\n",
+    "        text = src if lang == SRC else tgt\n",
+    "        yield tokenizer[lang](text)\n",
+    "\n",
+    "# 5) vocab 빌드\n",
+    "vocab = {}\n",
+    "for lang in [SRC, TGT]:\n",
+    "    v = build_vocab_from_iterator(\n",
+    "        generate_tokens(raw_train, lang),\n",
+    "        min_freq=1,\n",
+    "        specials=specials,\n",
+    "        special_first=True,\n",
+    "    )\n",
+    "    v.set_default_index(UNK_IDX)\n",
+    "    vocab[lang] = v\n",
+    "\n",
+    "# 확인\n",
+    "print(\"German vocab size:\", len(vocab[\"de\"]))\n",
+    "print(\"English vocab size:\", len(vocab[\"en\"]))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import math\n",
+    "import torch\n",
+    "from torch import nn\n",
+    "\n",
+    "\n",
+    "class PositionalEncoding(nn.Module):\n",
+    "    def __init__(self, d_model, max_len, dropout=0.1):\n",
+    "        super().__init__()\n",
+    "        self.dropout = nn.Dropout(p=dropout)\n",
+    "\n",
+    "        position = torch.arange(max_len).unsqueeze(1)\n",
+    "        div_term = torch.exp(\n",
+    "            torch.arange(0, d_model, 2) * (-math.log(10000.0) / d_model)\n",
+    "        )\n",
+    "\n",
+    "        pe = torch.zeros(max_len, 1, d_model)\n",
+    "        pe[:, 0, 0::2] = torch.sin(position * div_term)\n",
+    "        pe[:, 0, 1::2] = torch.cos(position * div_term)\n",
+    "        self.register_buffer(\"pe\", pe)\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = x + self.pe[: x.size(0)]\n",
+    "        return self.dropout(x)\n",
+    "\n",
+    "\n",
+    "class TokenEmbedding(nn.Module):\n",
+    "    def __init__(self, vocab_size, emb_size):\n",
+    "        super().__init__()\n",
+    "        self.embedding = nn.Embedding(vocab_size, emb_size)\n",
+    "        self.emb_size = emb_size\n",
+    "\n",
+    "    def forward(self, tokens):\n",
+    "        return self.embedding(tokens.long()) * math.sqrt(self.emb_size)\n",
+    "\n",
+    "\n",
+    "class Seq2SeqTransformer(nn.Module):\n",
+    "    def __init__(\n",
+    "        self,\n",
+    "        num_encoder_layers,\n",
+    "        num_decoder_layers,\n",
+    "        emb_size,\n",
+    "        max_len,\n",
+    "        nhead,\n",
+    "        src_vocab_size,\n",
+    "        tgt_vocab_size,\n",
+    "        dim_feedforward,\n",
+    "        dropout=0.1,\n",
+    "    ):\n",
+    "        super().__init__()\n",
+    "        self.src_tok_emb = TokenEmbedding(src_vocab_size, emb_size)\n",
+    "        self.tgt_tok_emb = TokenEmbedding(tgt_vocab_size, emb_size)\n",
+    "        self.positional_encoding = PositionalEncoding(\n",
+    "            d_model=emb_size, max_len=max_len, dropout=dropout\n",
+    "        )\n",
+    "        self.transformer = nn.Transformer(\n",
+    "            d_model=emb_size,\n",
+    "            nhead=nhead,\n",
+    "            num_encoder_layers=num_encoder_layers,\n",
+    "            num_decoder_layers=num_decoder_layers,\n",
+    "            dim_feedforward=dim_feedforward,\n",
+    "            dropout=dropout,\n",
+    "        )\n",
+    "        self.generator = nn.Linear(emb_size, tgt_vocab_size)\n",
+    "\n",
+    "    def forward(\n",
+    "        self,\n",
+    "        src,\n",
+    "        trg,\n",
+    "        src_mask,\n",
+    "        tgt_mask,\n",
+    "        src_padding_mask,\n",
+    "        tgt_padding_mask,\n",
+    "        memory_key_padding_mask,\n",
+    "    ):\n",
+    "        src_emb = self.positional_encoding(self.src_tok_emb(src))\n",
+    "        tgt_emb = self.positional_encoding(self.tgt_tok_emb(trg))\n",
+    "        outs = self.transformer(\n",
+    "            src=src_emb,\n",
+    "            tgt=tgt_emb,\n",
+    "            src_mask=src_mask,\n",
+    "            tgt_mask=tgt_mask,\n",
+    "            memory_mask=None,\n",
+    "            src_key_padding_mask=src_padding_mask,\n",
+    "            tgt_key_padding_mask=tgt_padding_mask,\n",
+    "            memory_key_padding_mask=memory_key_padding_mask\n",
+    "        )\n",
+    "        return self.generator(outs)\n",
+    "\n",
+    "    def encode(self, src, src_mask):\n",
+    "        return self.transformer.encoder(\n",
+    "            self.positional_encoding(self.src_tok_emb(src)), src_mask\n",
+    "        )\n",
+    "\n",
+    "    def decode(self, tgt, memory, tgt_mask):\n",
+    "        return self.transformer.decoder(\n",
+    "            self.positional_encoding(self.tgt_tok_emb(tgt)), memory, tgt_mask\n",
+    "        )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "src_tok_emb\n",
+      "└ embedding\n",
+      "tgt_tok_emb\n",
+      "└ embedding\n",
+      "positional_encoding\n",
+      "└ dropout\n",
+      "transformer\n",
+      "└ encoder\n",
+      "│  └ layers\n",
+      "│  │  └ 0\n",
+      "│  │  └ 1\n",
+      "│  │  └ 2\n",
+      "│  └ norm\n",
+      "└ decoder\n",
+      "│  └ layers\n",
+      "│  │  └ 0\n",
+      "│  │  └ 1\n",
+      "│  │  └ 2\n",
+      "│  └ norm\n",
+      "generator\n"
+     ]
+    }
+   ],
+   "source": [
+    "# --- 앞에서 build한 vocab 딕셔너리 ---\n",
+    "# vocab = {\"de\": de_vocab, \"en\": en_vocab}\n",
+    "\n",
+    "SRC_LANGUAGE, TGT_LANGUAGE = \"de\", \"en\"\n",
+    "PAD_IDX = 1  # 앞서 설정하신 패딩 인덱스\n",
+    "\n",
+    "# 모델 생성 시 vocab 대신 vocab_transform 이름으로 참조하거나\n",
+    "# 바로 vocab을 사용하세요.\n",
+    "model = Seq2SeqTransformer(\n",
+    "    num_encoder_layers=3,\n",
+    "    num_decoder_layers=3,\n",
+    "    emb_size=512,\n",
+    "    max_len=512,\n",
+    "    nhead=8,\n",
+    "    src_vocab_size=len(vocab[SRC_LANGUAGE]),   # ← 여기만 바뀜\n",
+    "    tgt_vocab_size=len(vocab[TGT_LANGUAGE]),   # ← 그리고 여기\n",
+    "    dim_feedforward=512,\n",
+    ").to(DEVICE)\n",
+    "\n",
+    "criterion = nn.CrossEntropyLoss(ignore_index=PAD_IDX).to(DEVICE)\n",
+    "optimizer = optim.Adam(model.parameters())\n",
+    "\n",
+    "for main_name, main_module in model.named_children():\n",
+    "    print(main_name)\n",
+    "    for sub_name, sub_module in main_module.named_children():\n",
+    "        print(\"└\", sub_name)\n",
+    "        for ssub_name, ssub_module in sub_module.named_children():\n",
+    "            print(\"│  └\", ssub_name)\n",
+    "            for sssub_name, sssub_module in ssub_module.named_children():\n",
+    "                print(\"│  │  └\", sssub_name)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "source_batch shape: torch.Size([35, 128])\n",
+      "target_batch shape: torch.Size([30, 128])\n",
+      "example source indices:\n",
+      " tensor([[   2,    2,    2,    2,    2],\n",
+      "        [  14,    5,    5,   21,    5],\n",
+      "        [  38,   12,   35,   31,   12],\n",
+      "        [  24,  281,   10,  957,   10],\n",
+      "        [ 243,    7, 1205,   18, 7190],\n",
+      "        [2744,    6,   32,  420, 2328],\n",
+      "        [8680,   83,   11,    0,    8],\n",
+      "        [  11,  245,   34,   11,   16],\n",
+      "        [  20,   11,  792,    6,   18],\n",
+      "        [ 892,    6,   13,    0,  362],\n",
+      "        [   3,  444,   17,  318, 3914],\n",
+      "        [   1,    4,    4,   11,   62],\n",
+      "        [   1,    3,    3,    3,    8],\n",
+      "        [   1,    1,    1,    1,   32],\n",
+      "        [   1,    1,    1,    1,    7],\n",
+      "        [   1,    1,    1,    1,    6],\n",
+      "        [   1,    1,    1,    1,  115],\n",
+      "        [   1,    1,    1,    1,  197],\n",
+      "        [   1,    1,    1,    1,    4],\n",
+      "        [   1,    1,    1,    1,    3],\n",
+      "        [   1,    1,    1,    1,    1],\n",
+      "        [   1,    1,    1,    1,    1],\n",
+      "        [   1,    1,    1,    1,    1],\n",
+      "        [   1,    1,    1,    1,    1],\n",
+      "        [   1,    1,    1,    1,    1],\n",
+      "        [   1,    1,    1,    1,    1],\n",
+      "        [   1,    1,    1,    1,    1],\n",
+      "        [   1,    1,    1,    1,    1],\n",
+      "        [   1,    1,    1,    1,    1],\n",
+      "        [   1,    1,    1,    1,    1],\n",
+      "        [   1,    1,    1,    1,    1],\n",
+      "        [   1,    1,    1,    1,    1],\n",
+      "        [   1,    1,    1,    1,    1],\n",
+      "        [   1,    1,    1,    1,    1],\n",
+      "        [   1,    1,    1,    1,    1]])\n",
+      "example target indices:\n",
+      " tensor([[   2,    2,    2,    2,    2],\n",
+      "        [   6,    6,    6,   19,    6],\n",
+      "        [  39,   12,   35,   36, 1489],\n",
+      "        [  13,  383,   21,  412,   12],\n",
+      "        [  36,    7,  759,   50,   21],\n",
+      "        [  17,    4,   96,    4,    4],\n",
+      "        [1667,   51,    9,   30,   31],\n",
+      "        [2541,  189,    4,  272,  748],\n",
+      "        [ 342,    9,   16,  382,   85],\n",
+      "        [   4,    4,  106, 1923,   10],\n",
+      "        [ 282,  439,  893,    9,   32],\n",
+      "        [   3,    5,    5,   28,    7],\n",
+      "        [   1,    3,    3, 5504,    4],\n",
+      "        [   1,    1,    1,   79,   77],\n",
+      "        [   1,    1,    1,  325,  184],\n",
+      "        [   1,    1,    1,    3,    5],\n",
+      "        [   1,    1,    1,    1,    3],\n",
+      "        [   1,    1,    1,    1,    1],\n",
+      "        [   1,    1,    1,    1,    1],\n",
+      "        [   1,    1,    1,    1,    1],\n",
+      "        [   1,    1,    1,    1,    1],\n",
+      "        [   1,    1,    1,    1,    1],\n",
+      "        [   1,    1,    1,    1,    1],\n",
+      "        [   1,    1,    1,    1,    1],\n",
+      "        [   1,    1,    1,    1,    1],\n",
+      "        [   1,    1,    1,    1,    1],\n",
+      "        [   1,    1,    1,    1,    1],\n",
+      "        [   1,    1,    1,    1,    1],\n",
+      "        [   1,    1,    1,    1,    1],\n",
+      "        [   1,    1,    1,    1,    1]])\n"
+     ]
+    }
+   ],
+   "source": [
+    "import requests\n",
+    "import gzip\n",
+    "import io\n",
+    "import math\n",
+    "import torch\n",
+    "from torch import nn\n",
+    "from torch.utils.data import DataLoader\n",
+    "from torch.nn.utils.rnn import pad_sequence\n",
+    "from torchtext.data.utils import get_tokenizer\n",
+    "from torchtext.vocab import build_vocab_from_iterator\n",
+    "\n",
+    "# === 0) 앞에서 정의한 download_and_read_gz 함수 재사용 ===\n",
+    "def download_and_read_gz(url):\n",
+    "    resp = requests.get(url)\n",
+    "    resp.raise_for_status()\n",
+    "    with gzip.GzipFile(fileobj=io.BytesIO(resp.content)) as gz:\n",
+    "        return [line.decode(\"utf-8\").strip() for line in gz]\n",
+    "\n",
+    "# === 1) train/valid 데이터 로드 ===\n",
+    "URLS = {\n",
+    "    \"train\": {\n",
+    "        \"de\": \"https://raw.githubusercontent.com/multi30k/dataset/master/data/task1/raw/train.de.gz\",\n",
+    "        \"en\": \"https://raw.githubusercontent.com/multi30k/dataset/master/data/task1/raw/train.en.gz\",\n",
+    "    },\n",
+    "    \"valid\": {\n",
+    "        \"de\": \"https://raw.githubusercontent.com/multi30k/dataset/master/data/task1/raw/val.de.gz\",\n",
+    "        \"en\": \"https://raw.githubusercontent.com/multi30k/dataset/master/data/task1/raw/val.en.gz\",\n",
+    "    }\n",
+    "}\n",
+    "\n",
+    "raw_data = {}\n",
+    "for split in [\"train\", \"valid\"]:\n",
+    "    de = download_and_read_gz(URLS[split][\"de\"])\n",
+    "    en = download_and_read_gz(URLS[split][\"en\"])\n",
+    "    raw_data[split] = list(zip(de, en))\n",
+    "\n",
+    "raw_train = raw_data[\"train\"]\n",
+    "raw_valid = raw_data[\"valid\"]\n",
+    "\n",
+    "# === 2) 토크나이저 및 vocab 생성 ===\n",
+    "SRC, TGT = \"de\", \"en\"\n",
+    "BOS_IDX, EOS_IDX, PAD_IDX, UNK_IDX = 2, 3, 1, 0\n",
+    "specials = [\"<unk>\", \"<pad>\", \"<bos>\", \"<eos>\"]\n",
+    "\n",
+    "tokenizer = {\n",
+    "    SRC: get_tokenizer(\"spacy\", language=\"de_core_news_sm\"),\n",
+    "    TGT: get_tokenizer(\"spacy\", language=\"en_core_web_sm\"),\n",
+    "}\n",
+    "\n",
+    "def generate_tokens(data, lang):\n",
+    "    idx = 0 if lang == SRC else 1\n",
+    "    for src, tgt in data:\n",
+    "        text = src if lang == SRC else tgt\n",
+    "        yield tokenizer[lang](text)\n",
+    "\n",
+    "vocab = {}\n",
+    "for lang in [SRC, TGT]:\n",
+    "    v = build_vocab_from_iterator(\n",
+    "        generate_tokens(raw_train, lang),\n",
+    "        min_freq=1,\n",
+    "        specials=specials,\n",
+    "        special_first=True,\n",
+    "    )\n",
+    "    v.set_default_index(UNK_IDX)\n",
+    "    vocab[lang] = v\n",
+    "\n",
+    "# === 3) 텍스트 → 토큰ID 변환 트랜스폼 정의 ===\n",
+    "def sequential_transforms(*transforms):\n",
+    "    def fn(txt):\n",
+    "        for transform in transforms:\n",
+    "            txt = transform(txt)\n",
+    "        return txt\n",
+    "    return fn\n",
+    "\n",
+    "def input_transform(token_ids):\n",
+    "    return torch.cat([\n",
+    "        torch.tensor([BOS_IDX]),\n",
+    "        torch.tensor(token_ids),\n",
+    "        torch.tensor([EOS_IDX])\n",
+    "    ])\n",
+    "\n",
+    "text_transform = {}\n",
+    "for lang in [SRC, TGT]:\n",
+    "    text_transform[lang] = sequential_transforms(\n",
+    "        tokenizer[lang],        # raw string → 리스트[str]\n",
+    "        vocab[lang],            # 리스트[str] → 리스트[int]\n",
+    "        input_transform         # 리스트[int] → Tensor[...]\n",
+    "    )\n",
+    "\n",
+    "# === 4) collate_fn & DataLoader 생성 ===\n",
+    "def collator(batch):\n",
+    "    src_batch, tgt_batch = [], []\n",
+    "    for src_str, tgt_str in batch:\n",
+    "        src_batch.append(text_transform[SRC](src_str))\n",
+    "        tgt_batch.append(text_transform[TGT](tgt_str))\n",
+    "    src_batch = pad_sequence(src_batch, padding_value=PAD_IDX)\n",
+    "    tgt_batch = pad_sequence(tgt_batch, padding_value=PAD_IDX)\n",
+    "    return src_batch, tgt_batch\n",
+    "\n",
+    "BATCH_SIZE = 128\n",
+    "valid_loader = DataLoader(raw_valid, batch_size=BATCH_SIZE, collate_fn=collator)\n",
+    "\n",
+    "# === 5) 한 배치 꺼내서 확인 ===\n",
+    "src_batch, tgt_batch = next(iter(valid_loader))\n",
+    "print(\"source_batch shape:\", src_batch.shape)   # (seq_len, batch)\n",
+    "print(\"target_batch shape:\", tgt_batch.shape)\n",
+    "print(\"example source indices:\\n\", src_batch[:, :5])\n",
+    "print(\"example target indices:\\n\", tgt_batch[:, :5])\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "src_mask: torch.Size([35, 35])\n",
+      "tensor([[0., 0., 0.,  ..., 0., 0., 0.],\n",
+      "        [0., 0., 0.,  ..., 0., 0., 0.],\n",
+      "        [0., 0., 0.,  ..., 0., 0., 0.],\n",
+      "        ...,\n",
+      "        [0., 0., 0.,  ..., 0., 0., 0.],\n",
+      "        [0., 0., 0.,  ..., 0., 0., 0.],\n",
+      "        [0., 0., 0.,  ..., 0., 0., 0.]])\n",
+      "tgt_mask: torch.Size([29, 29])\n",
+      "tensor([[0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+      "         0., 0., 0., 0., 0.],\n",
+      "        [-inf, 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+      "         0., 0., 0., 0., 0.],\n",
+      "        [-inf, -inf, 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+      "         0., 0., 0., 0., 0.],\n",
+      "        [-inf, -inf, -inf, 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+      "         0., 0., 0., 0., 0.],\n",
+      "        [-inf, -inf, -inf, -inf, 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+      "         0., 0., 0., 0., 0.],\n",
+      "        [-inf, -inf, -inf, -inf, -inf, 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+      "         0., 0., 0., 0., 0.],\n",
+      "        [-inf, -inf, -inf, -inf, -inf, -inf, 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+      "         0., 0., 0., 0., 0.],\n",
+      "        [-inf, -inf, -inf, -inf, -inf, -inf, -inf, 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+      "         0., 0., 0., 0., 0.],\n",
+      "        [-inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+      "         0., 0., 0., 0., 0.],\n",
+      "        [-inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+      "         0., 0., 0., 0., 0.],\n",
+      "        [-inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+      "         0., 0., 0., 0., 0.],\n",
+      "        [-inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+      "         0., 0., 0., 0., 0.],\n",
+      "        [-inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+      "         0., 0., 0., 0., 0.],\n",
+      "        [-inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+      "         0., 0., 0., 0., 0.],\n",
+      "        [-inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+      "         0., 0., 0., 0., 0.],\n",
+      "        [-inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+      "         0., 0., 0., 0., 0.],\n",
+      "        [-inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+      "         0., 0., 0., 0., 0.],\n",
+      "        [-inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, 0., 0., 0., 0., 0., 0., 0.,\n",
+      "         0., 0., 0., 0., 0.],\n",
+      "        [-inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, 0., 0., 0., 0., 0., 0.,\n",
+      "         0., 0., 0., 0., 0.],\n",
+      "        [-inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, 0., 0., 0., 0., 0.,\n",
+      "         0., 0., 0., 0., 0.],\n",
+      "        [-inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, 0., 0., 0., 0.,\n",
+      "         0., 0., 0., 0., 0.],\n",
+      "        [-inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, 0., 0., 0.,\n",
+      "         0., 0., 0., 0., 0.],\n",
+      "        [-inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, 0., 0.,\n",
+      "         0., 0., 0., 0., 0.],\n",
+      "        [-inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, 0.,\n",
+      "         0., 0., 0., 0., 0.],\n",
+      "        [-inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf,\n",
+      "         0., 0., 0., 0., 0.],\n",
+      "        [-inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf,\n",
+      "         -inf, 0., 0., 0., 0.],\n",
+      "        [-inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf,\n",
+      "         -inf, -inf, 0., 0., 0.],\n",
+      "        [-inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf,\n",
+      "         -inf, -inf, -inf, 0., 0.],\n",
+      "        [-inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf,\n",
+      "         -inf, -inf, -inf, -inf, 0.]])\n",
+      "src_pad_mask: torch.Size([128, 35])\n",
+      "tensor([[False, False, False,  ...,  True,  True,  True],\n",
+      "        [False, False, False,  ...,  True,  True,  True],\n",
+      "        [False, False, False,  ...,  True,  True,  True],\n",
+      "        ...,\n",
+      "        [False, False, False,  ...,  True,  True,  True],\n",
+      "        [False, False, False,  ...,  True,  True,  True],\n",
+      "        [False, False, False,  ...,  True,  True,  True]])\n",
+      "tgt_pad_mask: torch.Size([128, 29])\n",
+      "tensor([[False, False, False,  ...,  True,  True,  True],\n",
+      "        [False, False, False,  ...,  True,  True,  True],\n",
+      "        [False, False, False,  ...,  True,  True,  True],\n",
+      "        ...,\n",
+      "        [False, False, False,  ...,  True,  True,  True],\n",
+      "        [False, False, False,  ...,  True,  True,  True],\n",
+      "        [False, False, False,  ...,  True,  True,  True]])\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch\n",
+    "\n",
+    "# 이미 정의된 DEVICE, PAD_IDX 사용\n",
+    "# DEVICE = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
+    "# PAD_IDX = 1\n",
+    "\n",
+    "def generate_square_subsequent_mask(sz):\n",
+    "    mask = torch.triu(torch.ones((sz, sz), device=DEVICE)) == 1\n",
+    "    mask = (\n",
+    "        mask.float()\n",
+    "        .masked_fill(~mask, float(\"-inf\"))\n",
+    "        .masked_fill(mask, float(0.0))\n",
+    "    )\n",
+    "    return mask\n",
+    "\n",
+    "def create_mask(src, tgt_input):\n",
+    "    src_seq_len, _ = src.shape\n",
+    "    tgt_seq_len, _ = tgt_input.shape\n",
+    "\n",
+    "    # no future look-ahead for decoder\n",
+    "    tgt_mask = generate_square_subsequent_mask(tgt_seq_len)\n",
+    "    # encoder doesn't need causal mask\n",
+    "    src_mask = torch.zeros((src_seq_len, src_seq_len), device=DEVICE)\n",
+    "\n",
+    "    # padding masks: shape (batch, seq_len)\n",
+    "    src_padding_mask = (src == PAD_IDX).transpose(0, 1)\n",
+    "    tgt_padding_mask = (tgt_input == PAD_IDX).transpose(0, 1)\n",
+    "    return src_mask, tgt_mask, src_padding_mask, tgt_padding_mask\n",
+    "\n",
+    "# 예시: valid_loader 에서 배치 꺼내기\n",
+    "src_batch, tgt_batch = next(iter(valid_loader))  # src_batch: (S, B), tgt_batch: (T, B)\n",
+    "\n",
+    "# decoder input은 <bos> 부터 마지막 전까지\n",
+    "tgt_input = tgt_batch[:-1, :]\n",
+    "# 예측 대상(teacher forcing)은 두 번째 토큰부터 끝까지\n",
+    "tgt_out   = tgt_batch[1:, :]\n",
+    "\n",
+    "src_mask, tgt_mask, src_pad_mask, tgt_pad_mask = create_mask(src_batch, tgt_input)\n",
+    "\n",
+    "print(\"src_mask:\",  src_mask.shape)\n",
+    "print(src_mask)\n",
+    "\n",
+    "print(\"tgt_mask:\",  tgt_mask.shape)\n",
+    "print(tgt_mask)\n",
+    "\n",
+    "print(\"src_pad_mask:\",  src_pad_mask.shape)\n",
+    "print(src_pad_mask)\n",
+    "\n",
+    "print(\"tgt_pad_mask:\",  tgt_pad_mask.shape)\n",
+    "print(tgt_pad_mask)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "577080f70b824c5b905db5a3e9cef87f",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "config.json:   0%|          | 0.00/665 [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "1bcb6ef2268f4e8eb6ea0abdd2a48dbc",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "model.safetensors:   0%|          | 0.00/548M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "ada86301c0884c0699be24913c4159d3",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "generation_config.json:   0%|          | 0.00/124 [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "transformer\n",
+      "└ wte\n",
+      "└ wpe\n",
+      "└ drop\n",
+      "└ h\n",
+      "│  └ 0\n",
+      "│  │  └ ln_1\n",
+      "│  │  └ attn\n",
+      "│  │  └ ln_2\n",
+      "│  │  └ mlp\n",
+      "│  └ 1\n",
+      "│  │  └ ln_1\n",
+      "│  │  └ attn\n",
+      "│  │  └ ln_2\n",
+      "│  │  └ mlp\n",
+      "│  └ 2\n",
+      "│  │  └ ln_1\n",
+      "│  │  └ attn\n",
+      "│  │  └ ln_2\n",
+      "│  │  └ mlp\n",
+      "│  └ 3\n",
+      "│  │  └ ln_1\n",
+      "│  │  └ attn\n",
+      "│  │  └ ln_2\n",
+      "│  │  └ mlp\n",
+      "│  └ 4\n",
+      "│  │  └ ln_1\n",
+      "│  │  └ attn\n",
+      "│  │  └ ln_2\n",
+      "│  │  └ mlp\n",
+      "│  └ 5\n",
+      "│  │  └ ln_1\n",
+      "│  │  └ attn\n",
+      "│  │  └ ln_2\n",
+      "│  │  └ mlp\n",
+      "│  └ 6\n",
+      "│  │  └ ln_1\n",
+      "│  │  └ attn\n",
+      "│  │  └ ln_2\n",
+      "│  │  └ mlp\n",
+      "│  └ 7\n",
+      "│  │  └ ln_1\n",
+      "│  │  └ attn\n",
+      "│  │  └ ln_2\n",
+      "│  │  └ mlp\n",
+      "│  └ 8\n",
+      "│  │  └ ln_1\n",
+      "│  │  └ attn\n",
+      "│  │  └ ln_2\n",
+      "│  │  └ mlp\n",
+      "│  └ 9\n",
+      "│  │  └ ln_1\n",
+      "│  │  └ attn\n",
+      "│  │  └ ln_2\n",
+      "│  │  └ mlp\n",
+      "│  └ 10\n",
+      "│  │  └ ln_1\n",
+      "│  │  └ attn\n",
+      "│  │  └ ln_2\n",
+      "│  │  └ mlp\n",
+      "│  └ 11\n",
+      "│  │  └ ln_1\n",
+      "│  │  └ attn\n",
+      "│  │  └ ln_2\n",
+      "│  │  └ mlp\n",
+      "└ ln_f\n",
+      "lm_head\n"
+     ]
+    }
+   ],
+   "source": [
+    "from transformers import GPT2LMHeadModel\n",
+    "\n",
+    "\n",
+    "model = GPT2LMHeadModel.from_pretrained(pretrained_model_name_or_path=\"gpt2\")\n",
+    "\n",
+    "for main_name, main_module in model.named_children():\n",
+    "    print(main_name)\n",
+    "    for sub_name, sub_module in main_module.named_children():\n",
+    "        print(\"└\", sub_name)\n",
+    "        for ssub_name, ssub_module in sub_module.named_children():\n",
+    "            print(\"│  └\", ssub_name)\n",
+    "            for sssub_name, sssub_module in ssub_module.named_children():\n",
+    "                print(\"│  │  └\", sssub_name)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "b7b0ca7f91d544b8a8c61df25ff12313",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "tokenizer_config.json:   0%|          | 0.00/26.0 [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "1a7577e821404330a40555cb8da5f644",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "vocab.json:   0%|          | 0.00/1.04M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "c7e2762b40994e5f9c73ba71331c7bed",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "merges.txt:   0%|          | 0.00/456k [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "82cd7acd5f494a5094748ebe6faf4db1",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "tokenizer.json:   0%|          | 0.00/1.36M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Device set to use mps:0\n",
+      "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
+      "Both `max_new_tokens` (=256) and `max_length`(=20) seem to have been set. `max_new_tokens` will take precedence. Please refer to the documentation for more information. (https://huggingface.co/docs/transformers/main/en/main_classes/text_generation)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[{'generated_text': 'Machine learning is a new field that has gained traction as a field of study that focuses on the neural correlates of knowledge, so that we can better understand it.\\n\\nAs we have seen, most people are familiar with the concept of \"superintelligence\". In fact, they have been using it for a long time. It\\'s been used successfully to improve our understanding of our own behavior and to generate hypotheses about how we can better understand and improve our lives.\\n\\nWe have yet to find a single example of a superintelligence that we have not already seen: the human brain. When we think of a superintelligence, it is usually a very simple idea that we have not yet seen. In the last decade, we have learned that this idea holds in many ways, including that it is very fast. And when we talk about the human brain we don\\'t just mean \"the brain\". We also mean the brain where we experience the world. If you think about the brain of a person, you might say that there is a lot of activity in the cortex. We can imagine that you have a person\\'s brain in the same way that you experience the world. But if you think of a person\\'s brain, you might say that his brain is not as large as the one you have'}, {'generated_text': \"Machine learning is a very complicated field, and there are some very easy ways to build a comprehensive framework that can support any kind of problem.\\n\\nWhat is the most important thing?\\n\\nWe should focus on the critical parts of training our employees to learn from each other.\\n\\nWe should not be afraid to ask questions. We should ask them questions that we have heard before. We should ask them questions that we think we can answer.\\n\\nThe problem with this is that our employees are often the ones who will be the focus of these questions.\\n\\nWhich is why we think that when we ask questions, we should be asking them in a way that they will be the focus of the question.\\n\\nOf course, we have to be careful about asking questions that we have not heard before. We might ask questions that we have heard before, but we have to ask them in a way that they will be the focus once they have heard them.\\n\\nOnce we have learned from each other, we should work together to understand the questions that we are getting at.\\n\\nWhat's the best way to learn from the same people?\\n\\nWe should be able to learn from them and ask them questions different from each other.\\n\\nA good example of this\"}, {'generated_text': \"Machine learning is now a huge problem.\\n\\nCoupled with the ongoing research in AI, we've taken the next step in that direction. We've developed AI in the context of machine learning, but there's more. We developed a new machine learning approach that can be applied to humans within the next decade, and then we can say more about our approach.\\n\\nThese are the things we're doing right now.\\n\\nCoupled with the ongoing research in AI, we've taken the next step in that direction. We've developed AI in the context of machine learning, but there's more. We developed a new machine learning approach that can be applied to humans within the next decade, and then we can say more about our approach.\\n\\nWe've created a new kind of machine learning system that can be used to explore the way humans interact with machines. We've used machine learning to study brain processes.\\n\\nWe've introduced a new kind of AI-based learning system to interact with people. We've called it machine learning.\\n\\nWe've created a new kind of AI-based learning system to interact with people. We've called it machine learning.\\n\\nAs we look to next-generation AI, we're going to ask what is the future\"}]\n"
+     ]
+    }
+   ],
+   "source": [
+    "from transformers import pipeline\n",
+    "\n",
+    "generator = pipeline(\n",
+    "    task=\"text-generation\",\n",
+    "    model=\"gpt2\",\n",
+    "    framework=\"pt\",                # ← 여기 추가\n",
+    ")\n",
+    "outputs = generator(\n",
+    "    \"Machine learning is\",\n",
+    "    max_length=20,\n",
+    "    num_return_sequences=3,\n",
+    "    pad_token_id=generator.tokenizer.eos_token_id\n",
+    ")\n",
+    "print(outputs)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/opt/anaconda3/envs/mxnet39/lib/python3.9/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n",
+      "Disabling PyTorch because PyTorch >= 2.1 is required but found 2.0.1\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Train Dataset Length : 8550\n",
+      "Valid Dataset Length : 526\n",
+      "Test Dataset Length : 515\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch\n",
+    "from torchtext.datasets import CoLA\n",
+    "from transformers import AutoTokenizer\n",
+    "from torch.utils.data import DataLoader\n",
+    "\n",
+    "\n",
+    "def collator(batch, tokenizer, device):\n",
+    "    source, labels, texts = zip(*batch)\n",
+    "    tokenized = tokenizer(\n",
+    "        texts,\n",
+    "        padding=\"longest\",\n",
+    "        truncation=True,\n",
+    "        return_tensors=\"pt\"\n",
+    "    )\n",
+    "    input_ids = tokenized[\"input_ids\"].to(device)\n",
+    "    attention_mask = tokenized[\"attention_mask\"].to(device)\n",
+    "    labels = torch.tensor(labels, dtype=torch.long).to(device)\n",
+    "    return input_ids, attention_mask, labels\n",
+    "\n",
+    "\n",
+    "train_data = list(CoLA(split=\"train\"))\n",
+    "valid_data = list(CoLA(split=\"dev\"))\n",
+    "test_data = list(CoLA(split=\"test\"))\n",
+    "\n",
+    "tokenizer = AutoTokenizer.from_pretrained(\"gpt2\")\n",
+    "tokenizer.pad_token = tokenizer.eos_token\n",
+    "\n",
+    "epochs = 3\n",
+    "batch_size = 16\n",
+    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
+    "\n",
+    "train_dataloader = DataLoader(\n",
+    "    train_data,\n",
+    "    batch_size=batch_size,\n",
+    "    collate_fn=lambda x: collator(x, tokenizer, device),\n",
+    "    shuffle=True,\n",
+    ")\n",
+    "valid_dataloader = DataLoader(\n",
+    "    valid_data, batch_size=batch_size, collate_fn=lambda x: collator(x, tokenizer, device)\n",
+    ")\n",
+    "test_dataloader = DataLoader(\n",
+    "    test_data, batch_size=batch_size, collate_fn=lambda x: collator(x, tokenizer, device)\n",
+    ")\n",
+    "\n",
+    "print(\"Train Dataset Length :\", len(train_data))\n",
+    "print(\"Valid Dataset Length :\", len(valid_data))\n",
+    "print(\"Test Dataset Length :\", len(test_data))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Some weights of GPT2ForSequenceClassification were not initialized from the model checkpoint at gpt2 and are newly initialized: ['score.weight']\n",
+      "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch\n",
+    "from torch import optim\n",
+    "from transformers import GPT2ForSequenceClassification\n",
+    "\n",
+    "# 1) device 정의\n",
+    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
+    "\n",
+    "# 2) 모델 로드 및 디바이스 이동\n",
+    "model = GPT2ForSequenceClassification.from_pretrained(\n",
+    "    pretrained_model_name_or_path=\"gpt2\",\n",
+    "    num_labels=2\n",
+    ").to(device)\n",
+    "\n",
+    "# 3) 패딩 토큰 설정\n",
+    "model.config.pad_token_id = model.config.eos_token_id\n",
+    "\n",
+    "# 4) 옵티마이저 준비\n",
+    "optimizer = optim.Adam(model.parameters(), lr=5e-5)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "from torch import nn\n",
+    "\n",
+    "\n",
+    "def calc_accuracy(preds, labels):\n",
+    "    pred_flat = np.argmax(preds, axis=1).flatten()\n",
+    "    labels_flat = labels.flatten()\n",
+    "    return np.sum(pred_flat == labels_flat) / len(labels_flat)\n",
+    "\n",
+    "def train(model, optimizer, dataloader):\n",
+    "    model.train()\n",
+    "    train_loss = 0.0\n",
+    "\n",
+    "    for input_ids, attention_mask, labels in dataloader:\n",
+    "        outputs = model(\n",
+    "            input_ids=input_ids,\n",
+    "            attention_mask=attention_mask,\n",
+    "            labels=labels\n",
+    "        )\n",
+    "\n",
+    "        loss = outputs.loss\n",
+    "        train_loss += loss.item()\n",
+    "        \n",
+    "        optimizer.zero_grad()\n",
+    "        loss.backward()\n",
+    "        optimizer.step()\n",
+    "\n",
+    "    train_loss = train_loss / len(dataloader)\n",
+    "    return train_loss\n",
+    "\n",
+    "def evaluation(model, dataloader):\n",
+    "    with torch.no_grad():\n",
+    "        model.eval()\n",
+    "        val_loss, val_accuracy = 0.0, 0.0\n",
+    "        \n",
+    "        for input_ids, attention_mask, labels in dataloader:\n",
+    "            outputs = model(\n",
+    "                input_ids=input_ids,\n",
+    "                attention_mask=attention_mask,\n",
+    "                labels=labels\n",
+    "            )\n",
+    "            logits = outputs.logits\n",
+    "            loss = outputs.loss\n",
+    "\n",
+    "            logits = logits.detach().cpu().numpy()\n",
+    "            label_ids = labels.to(\"cpu\").numpy()\n",
+    "            accuracy = calc_accuracy(logits, label_ids)\n",
+    "            \n",
+    "            val_loss += loss.item()\n",
+    "            val_accuracy += accuracy\n",
+    "    \n",
+    "    val_loss = val_loss/len(dataloader)\n",
+    "    val_accuracy = val_accuracy/len(dataloader)\n",
+    "    return val_loss, val_accuracy\n",
+    "\n",
+    "\n",
+    "best_loss = 10000\n",
+    "for epoch in range(epochs):\n",
+    "    train_loss = train(model, optimizer, train_dataloader)\n",
+    "    val_loss, val_accuracy = evaluation(model, valid_dataloader)\n",
+    "    print(f\"Epoch {epoch + 1}: Train Loss: {train_loss:.4f} Val Loss: {val_loss:.4f} Val Accuracy {val_accuracy:.4f}\")\n",
+    "\n",
+    "    if val_loss < best_loss:\n",
+    "        best_loss = val_loss\n",
+    "        torch.save(model.state_dict(), \"../models/GPT2ForSequenceClassification.pt\")\n",
+    "        print(\"Saved the model weights\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model = GPT2ForSequenceClassification.from_pretrained(\n",
+    "    pretrained_model_name_or_path=\"gpt2\",\n",
+    "    num_labels=2\n",
+    ").to(device)\n",
+    "model.config.pad_token_id = model.config.eos_token_id\n",
+    "model.load_state_dict(torch.load(\"../models/GPT2ForSequenceClassification.pt\"))\n",
+    "\n",
+    "test_loss, test_accuracy = evaluation(model, test_dataloader)\n",
+    "print(f\"Test Loss : {test_loss:.4f}\")\n",
+    "print(f\"Test Accuracy : {test_accuracy:.4f}\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "base",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}