diff --git "a/Week12_\353\263\265\354\212\265\352\263\274\354\240\234_\355\225\250\354\230\210\353\246\260.ipynb" "b/Week12_\353\263\265\354\212\265\352\263\274\354\240\234_\355\225\250\354\230\210\353\246\260.ipynb"
new file mode 100644
index 0000000..03f0f3b
--- /dev/null
+++ "b/Week12_\353\263\265\354\212\265\352\263\274\354\240\234_\355\225\250\354\230\210\353\246\260.ipynb"
@@ -0,0 +1,580 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "source": [
+        "##**Text generation Experiment**\n",
+        "\n",
+        "- 이번 복습과제에는 GPT-2 모델을 사용한 텍스트 생생을 다룹니다. 🙂\n",
+        "- GPT-2는 약 40GB의 인터넷 텍스트 데이터로 훈련된 모델로 다음 단어 예측(next word prediction)을 목적으로 학습이 되었습니다\n",
+        "- Beam Search, Top-k sampling, Top-p sampling 과 같은 다양한 디코딩 기법들을 실험해보겠습니다."
+      ],
+      "metadata": {
+        "id": "8Gxy65cu8irm"
+      }
+    },
+    {
+      "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",
+      "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\""
+      ],
+      "metadata": {
+        "id": "Kd6ZRQmG8gWL"
+      },
+      "execution_count": 2,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "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"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "pEjO6IVs8gS0",
+        "outputId": "44d41d65-ff9a-406e-e7a7-a2642cfb8cba"
+      },
+      "execution_count": 3,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "/usr/local/lib/python3.11/dist-packages/huggingface_hub/utils/_auth.py:94: UserWarning: \n",
+            "The secret `HF_TOKEN` does not exist in your Colab secrets.\n",
+            "To authenticate with the Hugging Face Hub, create a token in your settings tab (https://huggingface.co/settings/tokens), set it as secret in your Google Colab and restart your session.\n",
+            "You will be able to reuse this secret in all of your notebooks.\n",
+            "Please note that authentication is recommended but still optional to access public models or datasets.\n",
+            "  warnings.warn(\n",
+            "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"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# model parameters을 확인해 봅시다.\n",
+        "GPT2.summary()"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "QI2_C2gw8gPq",
+        "outputId": "0ba9b49e-dae3-488e-d374-b38f998f007b"
+      },
+      "execution_count": 4,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "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"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#아래 코드를 실행해주세요-\n",
+        "import tensorflow as tf\n",
+        "tf.random.set_seed(SEED)"
+      ],
+      "metadata": {
+        "id": "cPFXwobg8gMJ"
+      },
+      "execution_count": 5,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "### **Greedy-Search**\n",
+        "- Greedy Search 에서는 각 시점마다 가장 확률이 높은 단어를 다음 단어로 선택합니다.\n",
+        "- 즉, 다음 단어는 아래와 같이 업데이트됩니다:\n",
+        "\n",
+        "$ wt=argmax wP(w|w1:t−1) $  \n",
+        "\n",
+        "> 즉, 각 타임스텝 𝑡마다 조건부 확률이 가장 높은 단어를 선택하는 것!\n",
+        "\n",
+        "\n",
+        "- 이 단순한 접근방식이 어떤 성능 차이를 보이는지 살펴봅시다."
+      ],
+      "metadata": {
+        "id": "zsX-xn93-tUP"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# context를 encoder해주세요\n",
+        "input_ids = tokenizer.encode(input_sequence, return_tensors=\"tf\")\n",
+        "\n",
+        "# 텍스트 생성하기, 이때 output length가 (context length 포함) 50이 될 때까지\n",
+        "greedy_output = GPT2.generate(input_ids, max_length=50, do_sample=False)\n",
+        "\n",
+        "# output sequences 출력하기\n",
+        "print(\"Output:\\n\" + 100 * '-')\n",
+        "print(tokenizer.decode(greedy_output[0], skip_special_tokens = True))"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "ig-oWtIA8gIq",
+        "outputId": "59fa11ae-1475-4c78-fb20-239847e23cf2"
+      },
+      "execution_count": 6,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "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"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "💡**위 Greedy Search 식과 코드 결과를 보고 고려되는 주요 문제점을 해당 셀을 풀고 설명해주세요.**\n",
+        "\n",
+        "\n",
+        "---\n",
+        "\n",
+        "\n",
+        "- 다양하고 창의적인 텍스트 생성이 어려워서 생성 결과가 반복적일 수 있다.\n",
+        "- max_length까지의 토큰만을 출력하기 때문에 문장이 마무리 되지 않은 채로 출력이 되는 문제가 발생해 결과가 어색할 수 있다."
+      ],
+      "metadata": {
+        "id": "gVj1neC__f2N"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "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 결과를 모두 출력하여 비교해볼 수 있습니다."
+      ],
+      "metadata": {
+        "id": "3EC0shCGAAQq"
+      }
+    },
+    {
+      "cell_type": "code",
+      "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",
+        "    no_repeat_ngram_size=2,\n",
+        "    early_stopping=True\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)))"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "l6OrEzA684Np",
+        "outputId": "c0b4561a-3504-445a-aa6b-4356174d8a18"
+      },
+      "execution_count": 7,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "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 sit down and watch a movie.\"\n",
+            "\n",
+            "\"I know, I know,\" you say. \"But I\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 sit down and watch a movie.\"\n",
+            "\n",
+            "\"I know, I know,\" you say. \"I'm\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 sit down and watch a movie.\"\n",
+            "\n",
+            "\"I know, I know,\" you say. \"But you\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 sit down and watch a movie.\"\n",
+            "\n",
+            "\"I know, I know,\" you say, \"but I\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 down and watch a movie.\"\n",
+            "\n",
+            "\"I know, I know,\" you say. \"I just\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "💡**아래 그래프는 Beam Search의 결과와 실제 인간의 말하기 방식 사이의 차이를 보여줍니다. 위 Beam Search 코드 결과와 아래 그래프를  보고 고려되는 주요 문제점을 해당 셀을 풀고 설명해주세요. (기재된 논문에서 힌트를 찾을 수 있습니다.)**\n",
+        "\n",
+        "\n",
+        "---\n",
+        "\n",
+        "\n",
+        "-  인간의 언어는 불규칙성을 포함하고 있으나 Beam Search의 결과는 확률이 높은 경로만을 탐색하기 때문에, 생성 결과는 창의성이 부족하게 된다.\n",
+        "- Beam Search는 동일한 입력에 대해 유사한 출력을 생성하는 경향이 있기 때문에 다양한 결과를 생성하는 데 한계가 있다.\n",
+        "- Beam Search는 높은 확률의 토큰을 선택하여 반복적인 문장을 생성하는 경향이 있기 때문에 결과가 예측 가능하게 된다."
+      ],
+      "metadata": {
+        "id": "_VhLZdJlBVZk"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "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"
+      ],
+      "metadata": {
+        "id": "aOBGUk2aAwQ-"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "### **Basic Sampling**\n",
+        "- 이 방식은 가장 확률이 높은 문장을 찾는 경로를 고집하지 않고, 각 시점에서 조건부 확률 분포에 따라 무작위로 다음 단어를 선택합니다.\n",
+        "\n",
+        "$w t​ ∼P(w∣w 1:t−1)$\n",
+        "- 하지만 이렇게 무작위성이 추가되면, 생성된 문장이 일관성이 떨어지고 혼란스러워질 수 있습니다.\n",
+        "- 그래서 무작위성을 제어하기 위해 temperature 파라미터를 도입할 수 있습니다. 이 파라미터는 확률이 높은 단어의 선택 가능성을 높이고, 확률이 낮은 단어는 선택될 가능성을 줄여줍니다."
+      ],
+      "metadata": {
+        "id": "BcDagIp1BvFA"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# 샘플링을 구현하려면 do_sample = True만 설정하면 됩니다.\n",
+        "# temperature을 설정해주세요.\n",
+        "# 이때 top_k = 0으로 설정해주세요.\n",
+        "sample_output = GPT2.generate(\n",
+        "    input_ids,\n",
+        "    do_sample=True,\n",
+        "    max_length=50,\n",
+        "    temperature=1.0,\n",
+        "    top_k=0\n",
+        ")\n",
+        "# output sequences 출력하기\n",
+        "print(\"Output:\\n\" + 100 * '-')\n",
+        "print(tokenizer.decode(sample_output[0], skip_special_tokens = True))"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "z6pXSH2RBuz8",
+        "outputId": "94c95232-cdc6-4aff-a9c2-59f43a52caea"
+      },
+      "execution_count": 8,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "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 – play games. Believe it or not, it's not that difficult. Today I decided to take a break, hope that I was\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "💡**temperature 파라미터가 어떤 매커니즘으로  무작위성을 제어하는지  해당 셀을 풀고 설명해주세요.**\n",
+        "\n",
+        "\n",
+        "---\n",
+        "\n",
+        "- 모델이 생성할 단어를 결정하기 위해 소프트맥스 함수를 사용하는데, 여기에 temperature를 적용하면 걱 단어 후보의 로짓 값을 temperature로 나눈 뒤 확률로 변환한다. Temperature가 1보다 작으면 일관성 있고 보수적인 텍스트가 생성되고, 1보다 크면 다양하고 창의적인 문장이 생성되지만, 문맥과 맞지 않는 단어가 등장할 수 있다. 1일 경우에는, 원래 모델이 계산한 확률 분포를 그대로 사용한다."
+      ],
+      "metadata": {
+        "id": "8g2RrY7PFmjJ"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "### **Top-k Sampling**\n",
+        "- Top-K 샘플링에서는 다음 단어 후보 중 확률이 가장 높은 상위 K개 단어만 선택하고,\n",
+        "전체 probability mass을 이 K개의 단어에만 분배합니다.\n",
+        "\n",
+        "> 즉, 확률이 높은 단어의 선택 확률을 높이고, 낮은 단어의 확률을 줄이는 방식이 아니라,아예 확률이 낮은 단어들을 완전히 제거하는 방식!"
+      ],
+      "metadata": {
+        "id": "RzmrRsA8CmYs"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# top_k 값을 설정해서, 조건부 확률 분포에서 고려할 상위 단어 개수(K)를 지정해주세요!\n",
+        "sample_output = GPT2.generate(\n",
+        "    input_ids,\n",
+        "    do_sample=True,\n",
+        "    max_length=50,\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), '...')"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "WA-og6IeD1BZ",
+        "outputId": "9c3561ad-ffab-4d72-81c9-ac0310f2a35b"
+      },
+      "execution_count": 9,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "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 - the one thing I get to do when I leave home. And when I step into the kitchen, I want to use that one ...\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "### **Top-P Sampling(Nucleus Sampling)**\n",
+        "- Top-K 샘플링은 이전의 random sampling보다 더 일관된 텍스트를 생성하는 것으로 보입니다. 하지만 이보다 더나은 방법으로 Top-p sampling이 있습니다.\n",
+        "- Top-P 샘플링은 Top-K와 유사하지만,가장 확률이 높은 상위 K개 단어를 고르는 대신,누적 확률이 P 이상이 되는 최소한의 단어 집합을 선택합니다 그리고 전체 probability mass는 이 단어 집합에 재분배됩니다.\n"
+      ],
+      "metadata": {
+        "id": "2CgUegJOAw6h"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# top_p 파라미터를 통해 only from 80% most likely words 만  sample 해주세요.\n",
+        "sample_output = GPT2.generate(\n",
+        "    input_ids,\n",
+        "    do_sample=True,\n",
+        "    max_length=50,\n",
+        "    top_p=0.8,\n",
+        ")\n",
+        "# output sequences 출력하기\n",
+        "print(\"Output:\\n\" + 100 * '-')\n",
+        "print(tokenizer.decode(sample_output[0], skip_special_tokens = True), '...')"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "GEhy8PgbAr2f",
+        "outputId": "36fa68cf-144e-4587-ca60-70c087ff3bdf"
+      },
+      "execution_count": 10,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "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: take a bath. I'd even go as far as to say that it's my most important pre-work ritual, even if ...\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "### **Top-K + Top-P sampling**\n",
+        "- 둘을 동시에 사용하면, 확률이 매우 낮은 단어(이상한 단어)가 나올 가능성을 줄이면서도, 선택되는 단어 집합의 크기는 유동적으로 유지할 수 있습니다."
+      ],
+      "metadata": {
+        "id": "heGKePrAE46H"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# top_k와 top_p에 값을 지정하면 되고, temperature 파라미터도 함께 사용할 수 있습니다.\n",
+        "# 아래 코드를 완성해주세요.\n",
+        "# 이때 max_length= 2*MAX_LEN 으로 설정해주세요\n",
+        "sample_outputs = GPT2.generate(\n",
+        "    input_ids,\n",
+        "    do_sample=True,\n",
+        "    max_length=2*MAX_LEN,\n",
+        "    top_k=50,\n",
+        "    top_p=0.8,\n",
+        "    temperature=0.8,\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('')"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "Q8-CnW76E3FI",
+        "outputId": "f6a98ace-fdb5-45eb-e387-5021d06e7665"
+      },
+      "execution_count": 11,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "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: smoke a cigarette. But I don't want to smoke in my office. That would be rude. So I've made a rule: I don't smoke anywhere.\n",
+            "\n",
+            "I've also made a rule: I don't smoke anywhere in the building.\n",
+            "\n",
+            "The first rule is easy to remember. The second is more difficult.\n",
+            "\n",
+            "I'm going to tell you what my rule is: I don't smoke anywhere.\n",
+            "\n",
+            "I've been told that's a rule. I've been told that's a law.\n",
+            "\n",
+            "I've been told that's a rule...\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: go home, have a few drinks, and watch some TV.\n",
+            "\n",
+            "The problem with that is that it's not that easy.\n",
+            "\n",
+            "It's not that easy to get a drink at a bar or to get a beer at a bar.\n",
+            "\n",
+            "I'm going to be honest with you. I'm not a big drinker. I don't drink a lot of beer, but I do drink a lot of wine.\n",
+            "\n",
+            "And I'm not going to lie to you. I've had some bad experiences with getting a beer at a bar.\n",
+            "\n",
+            "Here...\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: sleep. I've been doing that for over three years now, and I'm still not happy.\n",
+            "\n",
+            "So I decided to give it a shot. I found a couple of websites that provide tips on how to get a good night's sleep. One of them is called SleepChart, and the other is Sleep-O-Meter. Both of them are free.\n",
+            "\n",
+            "I downloaded the SleepChart app and started sleeping on it. It's a very simple app, but it's very easy to use. It's like a clock, but it has a graph that...\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: watch a movie.\n",
+            "\n",
+            "The first time I saw a movie was at a party, when I was a kid. I was the only one there, and I couldn't find anything to watch. My parents were both very old-school, so they took me to see The Godfather.\n",
+            "\n",
+            "I watched it over and over again, and I still remember the feeling of being mesmerized by the action.\n",
+            "\n",
+            "It wasn't until a few years later, when I was in college, that I started to think about what it was that I wanted to do after college...\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 go home and relax. If you think I'm going to miss the show, you're wrong.\n",
+            "\n",
+            "The show will be back on the air on Wednesday, September 13th at 10pm ET.\n",
+            "\n",
+            "For more information about the show, check out our website, and follow us on Twitter @nbcuniverses....\n",
+            "\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "💡**Top-k와 Top-p의 방식의 차이에 대해 설명해주세요**\n",
+        "\n",
+        "\n",
+        "---\n",
+        "- Top-k 방식은 확률 순으로 정렬된 단어들 중 상위 k개만을 고정적으로 선택 후보로 삼고, 그중에서 무작위로 단어를 생성한다. 계산이 간단하지만, 분포에 상관없이 같은 수의 단어를 고려하므로 불필요한 단어가 포함될 수 있다.\n",
+        "- Top-p 방식은 전체 단어 확률의 누적합이 p를 초과하지 않는 단어들만 후보로 선택한다. 분포에 따라 포함되는 단어 수가 달라지므로 더 자연스러운 문장 생성이 가능하지만, 계산이 복잡하다."
+      ],
+      "metadata": {
+        "id": "s_TeJ5zXF6Ra"
+      }
+    }
+  ]
+}
\ No newline at end of file
diff --git "a/Week12_\354\230\210\354\212\265\352\263\274\354\240\234_\355\225\250\354\230\210\353\246\260.ipynb" "b/Week12_\354\230\210\354\212\265\352\263\274\354\240\234_\355\225\250\354\230\210\353\246\260.ipynb"
new file mode 100644
index 0000000..5a84e89
--- /dev/null
+++ "b/Week12_\354\230\210\354\212\265\352\263\274\354\240\234_\355\225\250\354\230\210\353\246\260.ipynb"
@@ -0,0 +1,1898 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "gpuType": "T4"
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    },
+    "accelerator": "GPU"
+  },
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**Transformer**"
+      ],
+      "metadata": {
+        "id": "RFxCMlpjc5hk"
+      }
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 455
+        },
+        "id": "pxdmDJ5tWpc3",
+        "outputId": "2d397dfc-c133-4156-c41a-c784db8bb0c6"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 2 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "#위치 인코딩\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",
+        "\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",
+        "encoding=PositionalEncoding(d_model=128, max_len=50)\n",
+        "\n",
+        "plt.pcolormesh(encoding.pe.numpy().squeeze(), cmap=\"RdBu\")\n",
+        "plt.xlabel(\"Embedding Dimension\")\n",
+        "plt.xlim((0,128))\n",
+        "plt.ylabel(\"Position\")\n",
+        "plt.colorbar()\n",
+        "plt.show()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!pip install torchdata torchtext portalocker"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "4EYtOVVm3xmJ",
+        "outputId": "9aa7f204-009f-422d-fe20-5f890b968479"
+      },
+      "execution_count": 2,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Requirement already satisfied: torchdata in /usr/local/lib/python3.11/dist-packages (0.11.0)\n",
+            "Collecting torchtext\n",
+            "  Downloading torchtext-0.18.0-cp311-cp311-manylinux1_x86_64.whl.metadata (7.9 kB)\n",
+            "Collecting portalocker\n",
+            "  Downloading portalocker-3.1.1-py3-none-any.whl.metadata (8.6 kB)\n",
+            "Requirement already satisfied: urllib3>=1.25 in /usr/local/lib/python3.11/dist-packages (from torchdata) (2.4.0)\n",
+            "Requirement already satisfied: requests in /usr/local/lib/python3.11/dist-packages (from torchdata) (2.32.3)\n",
+            "Requirement already satisfied: torch>=2 in /usr/local/lib/python3.11/dist-packages (from torchdata) (2.6.0+cu124)\n",
+            "Requirement already satisfied: tqdm in /usr/local/lib/python3.11/dist-packages (from torchtext) (4.67.1)\n",
+            "Requirement already satisfied: numpy in /usr/local/lib/python3.11/dist-packages (from torchtext) (2.0.2)\n",
+            "Requirement already satisfied: filelock in /usr/local/lib/python3.11/dist-packages (from torch>=2->torchdata) (3.18.0)\n",
+            "Requirement already satisfied: typing-extensions>=4.10.0 in /usr/local/lib/python3.11/dist-packages (from torch>=2->torchdata) (4.13.2)\n",
+            "Requirement already satisfied: networkx in /usr/local/lib/python3.11/dist-packages (from torch>=2->torchdata) (3.4.2)\n",
+            "Requirement already satisfied: jinja2 in /usr/local/lib/python3.11/dist-packages (from torch>=2->torchdata) (3.1.6)\n",
+            "Requirement already satisfied: fsspec in /usr/local/lib/python3.11/dist-packages (from torch>=2->torchdata) (2025.3.2)\n",
+            "Collecting nvidia-cuda-nvrtc-cu12==12.4.127 (from torch>=2->torchdata)\n",
+            "  Downloading nvidia_cuda_nvrtc_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl.metadata (1.5 kB)\n",
+            "Collecting nvidia-cuda-runtime-cu12==12.4.127 (from torch>=2->torchdata)\n",
+            "  Downloading nvidia_cuda_runtime_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl.metadata (1.5 kB)\n",
+            "Collecting nvidia-cuda-cupti-cu12==12.4.127 (from torch>=2->torchdata)\n",
+            "  Downloading nvidia_cuda_cupti_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl.metadata (1.6 kB)\n",
+            "Collecting nvidia-cudnn-cu12==9.1.0.70 (from torch>=2->torchdata)\n",
+            "  Downloading nvidia_cudnn_cu12-9.1.0.70-py3-none-manylinux2014_x86_64.whl.metadata (1.6 kB)\n",
+            "Collecting nvidia-cublas-cu12==12.4.5.8 (from torch>=2->torchdata)\n",
+            "  Downloading nvidia_cublas_cu12-12.4.5.8-py3-none-manylinux2014_x86_64.whl.metadata (1.5 kB)\n",
+            "Collecting nvidia-cufft-cu12==11.2.1.3 (from torch>=2->torchdata)\n",
+            "  Downloading nvidia_cufft_cu12-11.2.1.3-py3-none-manylinux2014_x86_64.whl.metadata (1.5 kB)\n",
+            "Collecting nvidia-curand-cu12==10.3.5.147 (from torch>=2->torchdata)\n",
+            "  Downloading nvidia_curand_cu12-10.3.5.147-py3-none-manylinux2014_x86_64.whl.metadata (1.5 kB)\n",
+            "Collecting nvidia-cusolver-cu12==11.6.1.9 (from torch>=2->torchdata)\n",
+            "  Downloading nvidia_cusolver_cu12-11.6.1.9-py3-none-manylinux2014_x86_64.whl.metadata (1.6 kB)\n",
+            "Collecting nvidia-cusparse-cu12==12.3.1.170 (from torch>=2->torchdata)\n",
+            "  Downloading nvidia_cusparse_cu12-12.3.1.170-py3-none-manylinux2014_x86_64.whl.metadata (1.6 kB)\n",
+            "Requirement already satisfied: nvidia-cusparselt-cu12==0.6.2 in /usr/local/lib/python3.11/dist-packages (from torch>=2->torchdata) (0.6.2)\n",
+            "Requirement already satisfied: nvidia-nccl-cu12==2.21.5 in /usr/local/lib/python3.11/dist-packages (from torch>=2->torchdata) (2.21.5)\n",
+            "Requirement already satisfied: nvidia-nvtx-cu12==12.4.127 in /usr/local/lib/python3.11/dist-packages (from torch>=2->torchdata) (12.4.127)\n",
+            "Collecting nvidia-nvjitlink-cu12==12.4.127 (from torch>=2->torchdata)\n",
+            "  Downloading nvidia_nvjitlink_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl.metadata (1.5 kB)\n",
+            "Requirement already satisfied: triton==3.2.0 in /usr/local/lib/python3.11/dist-packages (from torch>=2->torchdata) (3.2.0)\n",
+            "Requirement already satisfied: sympy==1.13.1 in /usr/local/lib/python3.11/dist-packages (from torch>=2->torchdata) (1.13.1)\n",
+            "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.11/dist-packages (from sympy==1.13.1->torch>=2->torchdata) (1.3.0)\n",
+            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.11/dist-packages (from requests->torchdata) (3.4.2)\n",
+            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.11/dist-packages (from requests->torchdata) (3.10)\n",
+            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.11/dist-packages (from requests->torchdata) (2025.4.26)\n",
+            "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.11/dist-packages (from jinja2->torch>=2->torchdata) (3.0.2)\n",
+            "Downloading torchtext-0.18.0-cp311-cp311-manylinux1_x86_64.whl (2.0 MB)\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.0/2.0 MB\u001b[0m \u001b[31m20.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hDownloading portalocker-3.1.1-py3-none-any.whl (19 kB)\n",
+            "Downloading nvidia_cublas_cu12-12.4.5.8-py3-none-manylinux2014_x86_64.whl (363.4 MB)\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m363.4/363.4 MB\u001b[0m \u001b[31m1.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hDownloading nvidia_cuda_cupti_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl (13.8 MB)\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m13.8/13.8 MB\u001b[0m \u001b[31m99.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hDownloading nvidia_cuda_nvrtc_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl (24.6 MB)\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m24.6/24.6 MB\u001b[0m \u001b[31m81.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hDownloading nvidia_cuda_runtime_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl (883 kB)\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m883.7/883.7 kB\u001b[0m \u001b[31m43.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hDownloading nvidia_cudnn_cu12-9.1.0.70-py3-none-manylinux2014_x86_64.whl (664.8 MB)\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m664.8/664.8 MB\u001b[0m \u001b[31m2.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hDownloading nvidia_cufft_cu12-11.2.1.3-py3-none-manylinux2014_x86_64.whl (211.5 MB)\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m211.5/211.5 MB\u001b[0m \u001b[31m5.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hDownloading nvidia_curand_cu12-10.3.5.147-py3-none-manylinux2014_x86_64.whl (56.3 MB)\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m56.3/56.3 MB\u001b[0m \u001b[31m10.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hDownloading nvidia_cusolver_cu12-11.6.1.9-py3-none-manylinux2014_x86_64.whl (127.9 MB)\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m127.9/127.9 MB\u001b[0m \u001b[31m7.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hDownloading nvidia_cusparse_cu12-12.3.1.170-py3-none-manylinux2014_x86_64.whl (207.5 MB)\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m207.5/207.5 MB\u001b[0m \u001b[31m4.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hDownloading nvidia_nvjitlink_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl (21.1 MB)\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m21.1/21.1 MB\u001b[0m \u001b[31m81.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hInstalling collected packages: portalocker, nvidia-nvjitlink-cu12, nvidia-curand-cu12, nvidia-cufft-cu12, nvidia-cuda-runtime-cu12, nvidia-cuda-nvrtc-cu12, nvidia-cuda-cupti-cu12, nvidia-cublas-cu12, nvidia-cusparse-cu12, nvidia-cudnn-cu12, nvidia-cusolver-cu12, torchtext\n",
+            "  Attempting uninstall: nvidia-nvjitlink-cu12\n",
+            "    Found existing installation: nvidia-nvjitlink-cu12 12.5.82\n",
+            "    Uninstalling nvidia-nvjitlink-cu12-12.5.82:\n",
+            "      Successfully uninstalled nvidia-nvjitlink-cu12-12.5.82\n",
+            "  Attempting uninstall: nvidia-curand-cu12\n",
+            "    Found existing installation: nvidia-curand-cu12 10.3.6.82\n",
+            "    Uninstalling nvidia-curand-cu12-10.3.6.82:\n",
+            "      Successfully uninstalled nvidia-curand-cu12-10.3.6.82\n",
+            "  Attempting uninstall: nvidia-cufft-cu12\n",
+            "    Found existing installation: nvidia-cufft-cu12 11.2.3.61\n",
+            "    Uninstalling nvidia-cufft-cu12-11.2.3.61:\n",
+            "      Successfully uninstalled nvidia-cufft-cu12-11.2.3.61\n",
+            "  Attempting uninstall: nvidia-cuda-runtime-cu12\n",
+            "    Found existing installation: nvidia-cuda-runtime-cu12 12.5.82\n",
+            "    Uninstalling nvidia-cuda-runtime-cu12-12.5.82:\n",
+            "      Successfully uninstalled nvidia-cuda-runtime-cu12-12.5.82\n",
+            "  Attempting uninstall: nvidia-cuda-nvrtc-cu12\n",
+            "    Found existing installation: nvidia-cuda-nvrtc-cu12 12.5.82\n",
+            "    Uninstalling nvidia-cuda-nvrtc-cu12-12.5.82:\n",
+            "      Successfully uninstalled nvidia-cuda-nvrtc-cu12-12.5.82\n",
+            "  Attempting uninstall: nvidia-cuda-cupti-cu12\n",
+            "    Found existing installation: nvidia-cuda-cupti-cu12 12.5.82\n",
+            "    Uninstalling nvidia-cuda-cupti-cu12-12.5.82:\n",
+            "      Successfully uninstalled nvidia-cuda-cupti-cu12-12.5.82\n",
+            "  Attempting uninstall: nvidia-cublas-cu12\n",
+            "    Found existing installation: nvidia-cublas-cu12 12.5.3.2\n",
+            "    Uninstalling nvidia-cublas-cu12-12.5.3.2:\n",
+            "      Successfully uninstalled nvidia-cublas-cu12-12.5.3.2\n",
+            "  Attempting uninstall: nvidia-cusparse-cu12\n",
+            "    Found existing installation: nvidia-cusparse-cu12 12.5.1.3\n",
+            "    Uninstalling nvidia-cusparse-cu12-12.5.1.3:\n",
+            "      Successfully uninstalled nvidia-cusparse-cu12-12.5.1.3\n",
+            "  Attempting uninstall: nvidia-cudnn-cu12\n",
+            "    Found existing installation: nvidia-cudnn-cu12 9.3.0.75\n",
+            "    Uninstalling nvidia-cudnn-cu12-9.3.0.75:\n",
+            "      Successfully uninstalled nvidia-cudnn-cu12-9.3.0.75\n",
+            "  Attempting uninstall: nvidia-cusolver-cu12\n",
+            "    Found existing installation: nvidia-cusolver-cu12 11.6.3.83\n",
+            "    Uninstalling nvidia-cusolver-cu12-11.6.3.83:\n",
+            "      Successfully uninstalled nvidia-cusolver-cu12-11.6.3.83\n",
+            "Successfully installed nvidia-cublas-cu12-12.4.5.8 nvidia-cuda-cupti-cu12-12.4.127 nvidia-cuda-nvrtc-cu12-12.4.127 nvidia-cuda-runtime-cu12-12.4.127 nvidia-cudnn-cu12-9.1.0.70 nvidia-cufft-cu12-11.2.1.3 nvidia-curand-cu12-10.3.5.147 nvidia-cusolver-cu12-11.6.1.9 nvidia-cusparse-cu12-12.3.1.170 nvidia-nvjitlink-cu12-12.4.127 portalocker-3.1.1 torchtext-0.18.0\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!pip uninstall torchtext -y\n",
+        "!pip install torchtext==0.17.0"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000
+        },
+        "id": "fU3U7Lv3eGEF",
+        "outputId": "7b60bce7-4ec0-48fe-930b-972a7396e6cf"
+      },
+      "execution_count": 3,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Found existing installation: torchtext 0.18.0\n",
+            "Uninstalling torchtext-0.18.0:\n",
+            "  Successfully uninstalled torchtext-0.18.0\n",
+            "Collecting torchtext==0.17.0\n",
+            "  Downloading torchtext-0.17.0-cp311-cp311-manylinux1_x86_64.whl.metadata (7.6 kB)\n",
+            "Requirement already satisfied: tqdm in /usr/local/lib/python3.11/dist-packages (from torchtext==0.17.0) (4.67.1)\n",
+            "Requirement already satisfied: requests in /usr/local/lib/python3.11/dist-packages (from torchtext==0.17.0) (2.32.3)\n",
+            "Collecting torch==2.2.0 (from torchtext==0.17.0)\n",
+            "  Downloading torch-2.2.0-cp311-cp311-manylinux1_x86_64.whl.metadata (25 kB)\n",
+            "Requirement already satisfied: numpy in /usr/local/lib/python3.11/dist-packages (from torchtext==0.17.0) (2.0.2)\n",
+            "Collecting torchdata==0.7.1 (from torchtext==0.17.0)\n",
+            "  Downloading torchdata-0.7.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (13 kB)\n",
+            "Requirement already satisfied: filelock in /usr/local/lib/python3.11/dist-packages (from torch==2.2.0->torchtext==0.17.0) (3.18.0)\n",
+            "Requirement already satisfied: typing-extensions>=4.8.0 in /usr/local/lib/python3.11/dist-packages (from torch==2.2.0->torchtext==0.17.0) (4.13.2)\n",
+            "Requirement already satisfied: sympy in /usr/local/lib/python3.11/dist-packages (from torch==2.2.0->torchtext==0.17.0) (1.13.1)\n",
+            "Requirement already satisfied: networkx in /usr/local/lib/python3.11/dist-packages (from torch==2.2.0->torchtext==0.17.0) (3.4.2)\n",
+            "Requirement already satisfied: jinja2 in /usr/local/lib/python3.11/dist-packages (from torch==2.2.0->torchtext==0.17.0) (3.1.6)\n",
+            "Requirement already satisfied: fsspec in /usr/local/lib/python3.11/dist-packages (from torch==2.2.0->torchtext==0.17.0) (2025.3.2)\n",
+            "Collecting nvidia-cuda-nvrtc-cu12==12.1.105 (from torch==2.2.0->torchtext==0.17.0)\n",
+            "  Downloading nvidia_cuda_nvrtc_cu12-12.1.105-py3-none-manylinux1_x86_64.whl.metadata (1.5 kB)\n",
+            "Collecting nvidia-cuda-runtime-cu12==12.1.105 (from torch==2.2.0->torchtext==0.17.0)\n",
+            "  Downloading nvidia_cuda_runtime_cu12-12.1.105-py3-none-manylinux1_x86_64.whl.metadata (1.5 kB)\n",
+            "Collecting nvidia-cuda-cupti-cu12==12.1.105 (from torch==2.2.0->torchtext==0.17.0)\n",
+            "  Downloading nvidia_cuda_cupti_cu12-12.1.105-py3-none-manylinux1_x86_64.whl.metadata (1.6 kB)\n",
+            "Collecting nvidia-cudnn-cu12==8.9.2.26 (from torch==2.2.0->torchtext==0.17.0)\n",
+            "  Downloading nvidia_cudnn_cu12-8.9.2.26-py3-none-manylinux1_x86_64.whl.metadata (1.6 kB)\n",
+            "Collecting nvidia-cublas-cu12==12.1.3.1 (from torch==2.2.0->torchtext==0.17.0)\n",
+            "  Downloading nvidia_cublas_cu12-12.1.3.1-py3-none-manylinux1_x86_64.whl.metadata (1.5 kB)\n",
+            "Collecting nvidia-cufft-cu12==11.0.2.54 (from torch==2.2.0->torchtext==0.17.0)\n",
+            "  Downloading nvidia_cufft_cu12-11.0.2.54-py3-none-manylinux1_x86_64.whl.metadata (1.5 kB)\n",
+            "Collecting nvidia-curand-cu12==10.3.2.106 (from torch==2.2.0->torchtext==0.17.0)\n",
+            "  Downloading nvidia_curand_cu12-10.3.2.106-py3-none-manylinux1_x86_64.whl.metadata (1.5 kB)\n",
+            "Collecting nvidia-cusolver-cu12==11.4.5.107 (from torch==2.2.0->torchtext==0.17.0)\n",
+            "  Downloading nvidia_cusolver_cu12-11.4.5.107-py3-none-manylinux1_x86_64.whl.metadata (1.6 kB)\n",
+            "Collecting nvidia-cusparse-cu12==12.1.0.106 (from torch==2.2.0->torchtext==0.17.0)\n",
+            "  Downloading nvidia_cusparse_cu12-12.1.0.106-py3-none-manylinux1_x86_64.whl.metadata (1.6 kB)\n",
+            "Collecting nvidia-nccl-cu12==2.19.3 (from torch==2.2.0->torchtext==0.17.0)\n",
+            "  Downloading nvidia_nccl_cu12-2.19.3-py3-none-manylinux1_x86_64.whl.metadata (1.8 kB)\n",
+            "Collecting nvidia-nvtx-cu12==12.1.105 (from torch==2.2.0->torchtext==0.17.0)\n",
+            "  Downloading nvidia_nvtx_cu12-12.1.105-py3-none-manylinux1_x86_64.whl.metadata (1.7 kB)\n",
+            "Collecting triton==2.2.0 (from torch==2.2.0->torchtext==0.17.0)\n",
+            "  Downloading triton-2.2.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (1.4 kB)\n",
+            "Requirement already satisfied: urllib3>=1.25 in /usr/local/lib/python3.11/dist-packages (from torchdata==0.7.1->torchtext==0.17.0) (2.4.0)\n",
+            "Requirement already satisfied: nvidia-nvjitlink-cu12 in /usr/local/lib/python3.11/dist-packages (from nvidia-cusolver-cu12==11.4.5.107->torch==2.2.0->torchtext==0.17.0) (12.4.127)\n",
+            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.11/dist-packages (from requests->torchtext==0.17.0) (3.4.2)\n",
+            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.11/dist-packages (from requests->torchtext==0.17.0) (3.10)\n",
+            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.11/dist-packages (from requests->torchtext==0.17.0) (2025.4.26)\n",
+            "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.11/dist-packages (from jinja2->torch==2.2.0->torchtext==0.17.0) (3.0.2)\n",
+            "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.11/dist-packages (from sympy->torch==2.2.0->torchtext==0.17.0) (1.3.0)\n",
+            "Downloading torchtext-0.17.0-cp311-cp311-manylinux1_x86_64.whl (2.0 MB)\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.0/2.0 MB\u001b[0m \u001b[31m24.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hDownloading torch-2.2.0-cp311-cp311-manylinux1_x86_64.whl (755.5 MB)\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m755.5/755.5 MB\u001b[0m \u001b[31m2.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hDownloading torchdata-0.7.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (4.7 MB)\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m4.7/4.7 MB\u001b[0m \u001b[31m79.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hDownloading nvidia_cublas_cu12-12.1.3.1-py3-none-manylinux1_x86_64.whl (410.6 MB)\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m410.6/410.6 MB\u001b[0m \u001b[31m4.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hDownloading nvidia_cuda_cupti_cu12-12.1.105-py3-none-manylinux1_x86_64.whl (14.1 MB)\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m14.1/14.1 MB\u001b[0m \u001b[31m91.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hDownloading nvidia_cuda_nvrtc_cu12-12.1.105-py3-none-manylinux1_x86_64.whl (23.7 MB)\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m23.7/23.7 MB\u001b[0m \u001b[31m83.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hDownloading nvidia_cuda_runtime_cu12-12.1.105-py3-none-manylinux1_x86_64.whl (823 kB)\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m823.6/823.6 kB\u001b[0m \u001b[31m32.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hDownloading nvidia_cudnn_cu12-8.9.2.26-py3-none-manylinux1_x86_64.whl (731.7 MB)\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m731.7/731.7 MB\u001b[0m \u001b[31m2.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hDownloading nvidia_cufft_cu12-11.0.2.54-py3-none-manylinux1_x86_64.whl (121.6 MB)\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m121.6/121.6 MB\u001b[0m \u001b[31m7.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hDownloading nvidia_curand_cu12-10.3.2.106-py3-none-manylinux1_x86_64.whl (56.5 MB)\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m56.5/56.5 MB\u001b[0m \u001b[31m12.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hDownloading nvidia_cusolver_cu12-11.4.5.107-py3-none-manylinux1_x86_64.whl (124.2 MB)\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m124.2/124.2 MB\u001b[0m \u001b[31m7.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hDownloading nvidia_cusparse_cu12-12.1.0.106-py3-none-manylinux1_x86_64.whl (196.0 MB)\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m196.0/196.0 MB\u001b[0m \u001b[31m5.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hDownloading nvidia_nccl_cu12-2.19.3-py3-none-manylinux1_x86_64.whl (166.0 MB)\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m166.0/166.0 MB\u001b[0m \u001b[31m6.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hDownloading nvidia_nvtx_cu12-12.1.105-py3-none-manylinux1_x86_64.whl (99 kB)\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m99.1/99.1 kB\u001b[0m \u001b[31m6.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hDownloading triton-2.2.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (167.9 MB)\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m167.9/167.9 MB\u001b[0m \u001b[31m6.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hInstalling collected packages: triton, nvidia-nvtx-cu12, nvidia-nccl-cu12, nvidia-cusparse-cu12, nvidia-curand-cu12, nvidia-cufft-cu12, nvidia-cuda-runtime-cu12, nvidia-cuda-nvrtc-cu12, nvidia-cuda-cupti-cu12, nvidia-cublas-cu12, nvidia-cusolver-cu12, nvidia-cudnn-cu12, torch, torchdata, torchtext\n",
+            "  Attempting uninstall: triton\n",
+            "    Found existing installation: triton 3.2.0\n",
+            "    Uninstalling triton-3.2.0:\n",
+            "      Successfully uninstalled triton-3.2.0\n",
+            "  Attempting uninstall: nvidia-nvtx-cu12\n",
+            "    Found existing installation: nvidia-nvtx-cu12 12.4.127\n",
+            "    Uninstalling nvidia-nvtx-cu12-12.4.127:\n",
+            "      Successfully uninstalled nvidia-nvtx-cu12-12.4.127\n",
+            "  Attempting uninstall: nvidia-nccl-cu12\n",
+            "    Found existing installation: nvidia-nccl-cu12 2.21.5\n",
+            "    Uninstalling nvidia-nccl-cu12-2.21.5:\n",
+            "      Successfully uninstalled nvidia-nccl-cu12-2.21.5\n",
+            "  Attempting uninstall: nvidia-cusparse-cu12\n",
+            "    Found existing installation: nvidia-cusparse-cu12 12.3.1.170\n",
+            "    Uninstalling nvidia-cusparse-cu12-12.3.1.170:\n",
+            "      Successfully uninstalled nvidia-cusparse-cu12-12.3.1.170\n",
+            "  Attempting uninstall: nvidia-curand-cu12\n",
+            "    Found existing installation: nvidia-curand-cu12 10.3.5.147\n",
+            "    Uninstalling nvidia-curand-cu12-10.3.5.147:\n",
+            "      Successfully uninstalled nvidia-curand-cu12-10.3.5.147\n",
+            "  Attempting uninstall: nvidia-cufft-cu12\n",
+            "    Found existing installation: nvidia-cufft-cu12 11.2.1.3\n",
+            "    Uninstalling nvidia-cufft-cu12-11.2.1.3:\n",
+            "      Successfully uninstalled nvidia-cufft-cu12-11.2.1.3\n",
+            "  Attempting uninstall: nvidia-cuda-runtime-cu12\n",
+            "    Found existing installation: nvidia-cuda-runtime-cu12 12.4.127\n",
+            "    Uninstalling nvidia-cuda-runtime-cu12-12.4.127:\n",
+            "      Successfully uninstalled nvidia-cuda-runtime-cu12-12.4.127\n",
+            "  Attempting uninstall: nvidia-cuda-nvrtc-cu12\n",
+            "    Found existing installation: nvidia-cuda-nvrtc-cu12 12.4.127\n",
+            "    Uninstalling nvidia-cuda-nvrtc-cu12-12.4.127:\n",
+            "      Successfully uninstalled nvidia-cuda-nvrtc-cu12-12.4.127\n",
+            "  Attempting uninstall: nvidia-cuda-cupti-cu12\n",
+            "    Found existing installation: nvidia-cuda-cupti-cu12 12.4.127\n",
+            "    Uninstalling nvidia-cuda-cupti-cu12-12.4.127:\n",
+            "      Successfully uninstalled nvidia-cuda-cupti-cu12-12.4.127\n",
+            "  Attempting uninstall: nvidia-cublas-cu12\n",
+            "    Found existing installation: nvidia-cublas-cu12 12.4.5.8\n",
+            "    Uninstalling nvidia-cublas-cu12-12.4.5.8:\n",
+            "      Successfully uninstalled nvidia-cublas-cu12-12.4.5.8\n",
+            "  Attempting uninstall: nvidia-cusolver-cu12\n",
+            "    Found existing installation: nvidia-cusolver-cu12 11.6.1.9\n",
+            "    Uninstalling nvidia-cusolver-cu12-11.6.1.9:\n",
+            "      Successfully uninstalled nvidia-cusolver-cu12-11.6.1.9\n",
+            "  Attempting uninstall: nvidia-cudnn-cu12\n",
+            "    Found existing installation: nvidia-cudnn-cu12 9.1.0.70\n",
+            "    Uninstalling nvidia-cudnn-cu12-9.1.0.70:\n",
+            "      Successfully uninstalled nvidia-cudnn-cu12-9.1.0.70\n",
+            "  Attempting uninstall: torch\n",
+            "    Found existing installation: torch 2.6.0+cu124\n",
+            "    Uninstalling torch-2.6.0+cu124:\n",
+            "      Successfully uninstalled torch-2.6.0+cu124\n",
+            "  Attempting uninstall: torchdata\n",
+            "    Found existing installation: torchdata 0.11.0\n",
+            "    Uninstalling torchdata-0.11.0:\n",
+            "      Successfully uninstalled torchdata-0.11.0\n",
+            "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n",
+            "torchvision 0.21.0+cu124 requires torch==2.6.0, but you have torch 2.2.0 which is incompatible.\n",
+            "torchtune 0.6.1 requires torchdata==0.11.0, but you have torchdata 0.7.1 which is incompatible.\n",
+            "torchaudio 2.6.0+cu124 requires torch==2.6.0, but you have torch 2.2.0 which is incompatible.\u001b[0m\u001b[31m\n",
+            "\u001b[0mSuccessfully installed nvidia-cublas-cu12-12.1.3.1 nvidia-cuda-cupti-cu12-12.1.105 nvidia-cuda-nvrtc-cu12-12.1.105 nvidia-cuda-runtime-cu12-12.1.105 nvidia-cudnn-cu12-8.9.2.26 nvidia-cufft-cu12-11.0.2.54 nvidia-curand-cu12-10.3.2.106 nvidia-cusolver-cu12-11.4.5.107 nvidia-cusparse-cu12-12.1.0.106 nvidia-nccl-cu12-2.19.3 nvidia-nvtx-cu12-12.1.105 torch-2.2.0 torchdata-0.7.1 torchtext-0.17.0 triton-2.2.0\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "application/vnd.colab-display-data+json": {
+              "pip_warning": {
+                "packages": [
+                  "torch",
+                  "torchgen"
+                ]
+              },
+              "id": "f3713ab3badf4fa78efd311e79fdaa0e"
+            }
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!python -m spacy download de_core_news_sm\n",
+        "!python -m spacy download de_core_news_sm"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "hFVN4IdI1_SR",
+        "outputId": "b536fede-6d1f-4162-d65e-607c865c8dd9"
+      },
+      "execution_count": 4,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "\n",
+            "A module that was compiled using NumPy 1.x cannot be run in\n",
+            "NumPy 2.0.2 as it may crash. To support both 1.x and 2.x\n",
+            "versions of NumPy, modules must be compiled with NumPy 2.0.\n",
+            "Some module may need to rebuild instead e.g. with 'pybind11>=2.12'.\n",
+            "\n",
+            "If you are a user of the module, the easiest solution will be to\n",
+            "downgrade to 'numpy<2' or try to upgrade the affected module.\n",
+            "We expect that some modules will need time to support NumPy 2.\n",
+            "\n",
+            "Traceback (most recent call last):  File \"<frozen runpy>\", line 189, in _run_module_as_main\n",
+            "  File \"<frozen runpy>\", line 148, in _get_module_details\n",
+            "  File \"<frozen runpy>\", line 112, in _get_module_details\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/spacy/__init__.py\", line 6, in <module>\n",
+            "    from .errors import setup_default_warnings\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/spacy/errors.py\", line 3, in <module>\n",
+            "    from .compat import Literal\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/spacy/compat.py\", line 4, in <module>\n",
+            "    from thinc.util import copy_array\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/thinc/__init__.py\", line 5, in <module>\n",
+            "    from .config import registry\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/thinc/config.py\", line 5, in <module>\n",
+            "    from .types import Decorator\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/thinc/types.py\", line 27, in <module>\n",
+            "    from .compat import cupy, has_cupy\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/thinc/compat.py\", line 35, in <module>\n",
+            "    import torch\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/torch/__init__.py\", line 1471, in <module>\n",
+            "    from .functional import *  # noqa: F403\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/torch/functional.py\", line 9, in <module>\n",
+            "    import torch.nn.functional as F\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/torch/nn/__init__.py\", line 1, in <module>\n",
+            "    from .modules import *  # noqa: F403\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/torch/nn/modules/__init__.py\", line 35, in <module>\n",
+            "    from .transformer import TransformerEncoder, TransformerDecoder, \\\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/torch/nn/modules/transformer.py\", line 20, in <module>\n",
+            "    device: torch.device = torch.device(torch._C._get_default_device()),  # torch.device('cpu'),\n",
+            "/usr/local/lib/python3.11/dist-packages/torch/nn/modules/transformer.py:20: UserWarning: Failed to initialize NumPy: _ARRAY_API not found (Triggered internally at ../torch/csrc/utils/tensor_numpy.cpp:84.)\n",
+            "  device: torch.device = torch.device(torch._C._get_default_device()),  # torch.device('cpu'),\n",
+            "Collecting de-core-news-sm==3.8.0\n",
+            "  Downloading 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",
+            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m14.6/14.6 MB\u001b[0m \u001b[31m55.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hInstalling 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⚠ Restart to reload dependencies\u001b[0m\n",
+            "If you are in a Jupyter or Colab notebook, you may need to restart Python in\n",
+            "order to load all the package's dependencies. You can do this by selecting the\n",
+            "'Restart kernel' or 'Restart runtime' option.\n",
+            "\n",
+            "A module that was compiled using NumPy 1.x cannot be run in\n",
+            "NumPy 2.0.2 as it may crash. To support both 1.x and 2.x\n",
+            "versions of NumPy, modules must be compiled with NumPy 2.0.\n",
+            "Some module may need to rebuild instead e.g. with 'pybind11>=2.12'.\n",
+            "\n",
+            "If you are a user of the module, the easiest solution will be to\n",
+            "downgrade to 'numpy<2' or try to upgrade the affected module.\n",
+            "We expect that some modules will need time to support NumPy 2.\n",
+            "\n",
+            "Traceback (most recent call last):  File \"<frozen runpy>\", line 189, in _run_module_as_main\n",
+            "  File \"<frozen runpy>\", line 148, in _get_module_details\n",
+            "  File \"<frozen runpy>\", line 112, in _get_module_details\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/spacy/__init__.py\", line 6, in <module>\n",
+            "    from .errors import setup_default_warnings\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/spacy/errors.py\", line 3, in <module>\n",
+            "    from .compat import Literal\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/spacy/compat.py\", line 4, in <module>\n",
+            "    from thinc.util import copy_array\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/thinc/__init__.py\", line 5, in <module>\n",
+            "    from .config import registry\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/thinc/config.py\", line 5, in <module>\n",
+            "    from .types import Decorator\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/thinc/types.py\", line 27, in <module>\n",
+            "    from .compat import cupy, has_cupy\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/thinc/compat.py\", line 35, in <module>\n",
+            "    import torch\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/torch/__init__.py\", line 1471, in <module>\n",
+            "    from .functional import *  # noqa: F403\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/torch/functional.py\", line 9, in <module>\n",
+            "    import torch.nn.functional as F\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/torch/nn/__init__.py\", line 1, in <module>\n",
+            "    from .modules import *  # noqa: F403\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/torch/nn/modules/__init__.py\", line 35, in <module>\n",
+            "    from .transformer import TransformerEncoder, TransformerDecoder, \\\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/torch/nn/modules/transformer.py\", line 20, in <module>\n",
+            "    device: torch.device = torch.device(torch._C._get_default_device()),  # torch.device('cpu'),\n",
+            "/usr/local/lib/python3.11/dist-packages/torch/nn/modules/transformer.py:20: UserWarning: Failed to initialize NumPy: _ARRAY_API not found (Triggered internally at ../torch/csrc/utils/tensor_numpy.cpp:84.)\n",
+            "  device: torch.device = torch.device(torch._C._get_default_device()),  # torch.device('cpu'),\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",
+            "\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⚠ Restart to reload dependencies\u001b[0m\n",
+            "If you are in a Jupyter or Colab notebook, you may need to restart Python in\n",
+            "order to load all the package's dependencies. You can do this by selecting the\n",
+            "'Restart kernel' or 'Restart runtime' option.\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#데이터세트 다운로드 및 전처리\n",
+        "from torchtext.datasets import Multi30k\n",
+        "from torchtext.data.utils import get_tokenizer\n",
+        "from torchtext.vocab import build_vocab_from_iterator\n",
+        "\n",
+        "def generate_tokens(text_iter, language):\n",
+        "  language_index={SRC_LANGUAGE: 0, TGT_LANGUAGE: 1}\n",
+        "\n",
+        "  for text in text_iter:\n",
+        "    yield token_transform[language](text[language_index[language]])\n",
+        "\n",
+        "SRC_LANGUAGE=\"de\"\n",
+        "TGT_LANGUAGE=\"en\"\n",
+        "UNK_IDX, PAD_IDX, BOS_IDX, EOS_IDX=0, 1, 2, 3\n",
+        "special_symbols=[\"<unk>\", \"<pad>\", \"<bos>\", \"<eos>\"]\n",
+        "\n",
+        "token_transform={\n",
+        "    SRC_LANGUAGE: get_tokenizer(\"spacy\", language=\"de_core_news_sm\"),\n",
+        "    TGT_LANGUAGE: get_tokenizer(\"spacy\", language=\"en_core_web_sm\"),\n",
+        "}\n",
+        "print(\"Token Transform:\")\n",
+        "print(token_transform)\n",
+        "\n",
+        "vocab_transform={}\n",
+        "for language in [SRC_LANGUAGE, TGT_LANGUAGE]:\n",
+        "    train_iter=Multi30k(split=\"train\", language_pair=(SRC_LANGUAGE, TGT_LANGUAGE))\n",
+        "    vocab_transform[language]=build_vocab_from_iterator(\n",
+        "        generate_tokens(train_iter, language),\n",
+        "        min_freq=1,\n",
+        "        specials=special_symbols,\n",
+        "        special_first=True,\n",
+        "    )\n",
+        "\n",
+        "for language in [SRC_LANGUAGE, TGT_LANGUAGE]:\n",
+        "    vocab_transform[language].set_default_index(UNK_IDX)\n",
+        "\n",
+        "print(\"Vocab Transform:\")\n",
+        "print(vocab_transform)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "0LGQ4J3a4XPt",
+        "outputId": "bc361e58-ebb1-4648-c515-01b78df77fbd"
+      },
+      "execution_count": 1,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "\n",
+            "A module that was compiled using NumPy 1.x cannot be run in\n",
+            "NumPy 2.0.2 as it may crash. To support both 1.x and 2.x\n",
+            "versions of NumPy, modules must be compiled with NumPy 2.0.\n",
+            "Some module may need to rebuild instead e.g. with 'pybind11>=2.12'.\n",
+            "\n",
+            "If you are a user of the module, the easiest solution will be to\n",
+            "downgrade to 'numpy<2' or try to upgrade the affected module.\n",
+            "We expect that some modules will need time to support NumPy 2.\n",
+            "\n",
+            "Traceback (most recent call last):  File \"<frozen runpy>\", line 198, in _run_module_as_main\n",
+            "  File \"<frozen runpy>\", line 88, in _run_code\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/colab_kernel_launcher.py\", line 37, in <module>\n",
+            "    ColabKernelApp.launch_instance()\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/traitlets/config/application.py\", line 992, in launch_instance\n",
+            "    app.start()\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/ipykernel/kernelapp.py\", line 712, in start\n",
+            "    self.io_loop.start()\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/tornado/platform/asyncio.py\", line 205, in start\n",
+            "    self.asyncio_loop.run_forever()\n",
+            "  File \"/usr/lib/python3.11/asyncio/base_events.py\", line 608, in run_forever\n",
+            "    self._run_once()\n",
+            "  File \"/usr/lib/python3.11/asyncio/base_events.py\", line 1936, in _run_once\n",
+            "    handle._run()\n",
+            "  File \"/usr/lib/python3.11/asyncio/events.py\", line 84, in _run\n",
+            "    self._context.run(self._callback, *self._args)\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/ipykernel/kernelbase.py\", line 510, in dispatch_queue\n",
+            "    await self.process_one()\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/ipykernel/kernelbase.py\", line 499, in process_one\n",
+            "    await dispatch(*args)\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/ipykernel/kernelbase.py\", line 406, in dispatch_shell\n",
+            "    await result\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/ipykernel/kernelbase.py\", line 730, in execute_request\n",
+            "    reply_content = await reply_content\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/ipykernel/ipkernel.py\", line 383, in do_execute\n",
+            "    res = shell.run_cell(\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/ipykernel/zmqshell.py\", line 528, in run_cell\n",
+            "    return super().run_cell(*args, **kwargs)\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/IPython/core/interactiveshell.py\", line 2975, in run_cell\n",
+            "    result = self._run_cell(\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/IPython/core/interactiveshell.py\", line 3030, in _run_cell\n",
+            "    return runner(coro)\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/IPython/core/async_helpers.py\", line 78, in _pseudo_sync_runner\n",
+            "    coro.send(None)\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/IPython/core/interactiveshell.py\", line 3257, in run_cell_async\n",
+            "    has_raised = await self.run_ast_nodes(code_ast.body, cell_name,\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/IPython/core/interactiveshell.py\", line 3473, in run_ast_nodes\n",
+            "    if (await self.run_code(code, result,  async_=asy)):\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/IPython/core/interactiveshell.py\", line 3553, in run_code\n",
+            "    exec(code_obj, self.user_global_ns, self.user_ns)\n",
+            "  File \"<ipython-input-1-95788c996cff>\", line 2, in <cell line: 0>\n",
+            "    from torchtext.datasets import Multi30k\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/torchtext/__init__.py\", line 3, in <module>\n",
+            "    from torch.hub import _get_torch_home\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/torch/__init__.py\", line 1471, in <module>\n",
+            "    from .functional import *  # noqa: F403\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/torch/functional.py\", line 9, in <module>\n",
+            "    import torch.nn.functional as F\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/torch/nn/__init__.py\", line 1, in <module>\n",
+            "    from .modules import *  # noqa: F403\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/torch/nn/modules/__init__.py\", line 35, in <module>\n",
+            "    from .transformer import TransformerEncoder, TransformerDecoder, \\\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/torch/nn/modules/transformer.py\", line 20, in <module>\n",
+            "    device: torch.device = torch.device(torch._C._get_default_device()),  # torch.device('cpu'),\n",
+            "/usr/local/lib/python3.11/dist-packages/torch/nn/modules/transformer.py:20: UserWarning: Failed to initialize NumPy: _ARRAY_API not found (Triggered internally at ../torch/csrc/utils/tensor_numpy.cpp:84.)\n",
+            "  device: torch.device = torch.device(torch._C._get_default_device()),  # torch.device('cpu'),\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Token Transform:\n",
+            "{'de': functools.partial(<function _spacy_tokenize at 0x7be580c1bf60>, spacy=<spacy.lang.de.German object at 0x7be4b91abf50>), 'en': functools.partial(<function _spacy_tokenize at 0x7be580c1bf60>, spacy=<spacy.lang.en.English object at 0x7be4b8966450>)}\n",
+            "Vocab Transform:\n",
+            "{'de': Vocab(), 'en': Vocab()}\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#트랜스포머 모델 구성\n",
+        "import math\n",
+        "import torch\n",
+        "from torch import nn\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",
+        "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",
+        "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",
+        "        )"
+      ],
+      "metadata": {
+        "id": "o_kLlHYAJZD5"
+      },
+      "execution_count": 2,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#트랜스포머 클래스\n",
+        "#transformer=torch.nn.Transformer(\n",
+        "#    d_model=512,\n",
+        "#    nhead=8,\n",
+        "#    num_encoder_layers=6,\n",
+        "#    num_decoder_layers=6,\n",
+        "#    dim_feedforward=2048,\n",
+        "#    dropout=0.1,\n",
+        "#    activation=torch.nn.functional.relu,\n",
+        "#    layer_norm_eps=1e-05,\n",
+        "#)"
+      ],
+      "metadata": {
+        "id": "lQ67VUNlRlLx"
+      },
+      "execution_count": 3,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#트랜스포머 순방향 메서드\n",
+        "#output=transformer.forward(\n",
+        "#    src,\n",
+        "#    tgt,\n",
+        "#    src_mask=None,\n",
+        "#    tgt_mask=None,\n",
+        "#    memory_mask=None,\n",
+        "#    src_key_padding_mask=None,\n",
+        "#    tgt_key_padding_mask=None,\n",
+        "#    memory_key_padding_mask=None,\n",
+        "#)"
+      ],
+      "metadata": {
+        "id": "DAFmeLBOSkMe"
+      },
+      "execution_count": 4,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#트랜스포머 모델 구조\n",
+        "from torch import optim\n",
+        "\n",
+        "BATCH_SIZE=128\n",
+        "DEVICE=\"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
+        "\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_transform[SRC_LANGUAGE]),\n",
+        "    tgt_vocab_size=len(vocab_transform[TGT_LANGUAGE]),\n",
+        "    dim_feedforward=512,\n",
+        ").to(DEVICE)\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(\"L\", sub_name)\n",
+        "        for ssub_name, ssub_module in sub_module.named_children():\n",
+        "            print(\"| L\", ssub_name)\n",
+        "            for sssub_name, sssub_module in ssub_module.named_children():\n",
+        "                print(\"| | L\", sssub_name)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "omnRjLHJTmq4",
+        "outputId": "f2ae5e44-e89a-40f0-8630-8378c32b8bac"
+      },
+      "execution_count": 5,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "/usr/local/lib/python3.11/dist-packages/torch/nn/modules/transformer.py:286: UserWarning: enable_nested_tensor is True, but self.use_nested_tensor is False because encoder_layer.self_attn.batch_first was not True(use batch_first for better inference performance)\n",
+            "  warnings.warn(f\"enable_nested_tensor is True, but self.use_nested_tensor is False because {why_not_sparsity_fast_path}\")\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "src_tok_emb\n",
+            "L embedding\n",
+            "tgt_tok_emb\n",
+            "L embedding\n",
+            "positional_encoding\n",
+            "L dropout\n",
+            "transformer\n",
+            "L encoder\n",
+            "| L layers\n",
+            "| | L 0\n",
+            "| | L 1\n",
+            "| | L 2\n",
+            "| L norm\n",
+            "L decoder\n",
+            "| L layers\n",
+            "| | L 0\n",
+            "| | L 1\n",
+            "| | L 2\n",
+            "| L norm\n",
+            "generator\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#배치 데이터 생성\n",
+        "from torch.utils.data import DataLoader\n",
+        "from torch.nn.utils.rnn import pad_sequence\n",
+        "\n",
+        "def sequential_transforms(*transforms):\n",
+        "    def func(txt_input):\n",
+        "        for transform in transforms:\n",
+        "            txt_input=transform(txt_input)\n",
+        "        return txt_input\n",
+        "    return func\n",
+        "\n",
+        "def input_transform(token_ids):\n",
+        "    return torch.cat(\n",
+        "        (torch.tensor([BOS_IDX]), torch.tensor(token_ids), torch.tensor([EOS_IDX]))\n",
+        "  )\n",
+        "\n",
+        "def collator(batch):\n",
+        "    src_batch, tgt_batch=[], []\n",
+        "    for src_sample, tgt_sample in batch:\n",
+        "        src_batch.append(text_transform[SRC_LANGUAGE](src_sample.rstrip(\"\\n\")))\n",
+        "        tgt_batch.append(text_transform[TGT_LANGUAGE](tgt_sample.rstrip(\"\\n\")))\n",
+        "\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",
+        "text_transform={}\n",
+        "for language in [SRC_LANGUAGE, TGT_LANGUAGE]:\n",
+        "    text_transform[language]=sequential_transforms(\n",
+        "        token_transform[language], vocab_transform[language], input_transform\n",
+        "  )\n",
+        "\n",
+        "data_iter=Multi30k(split=\"valid\", language_pair=(SRC_LANGUAGE, TGT_LANGUAGE))\n",
+        "dataloader=DataLoader(data_iter, batch_size=BATCH_SIZE, collate_fn=collator)\n",
+        "source_tensor, target_tensor=next(iter(dataloader))\n",
+        "\n",
+        "print(\"(source, target):\")\n",
+        "print(next(iter(data_iter)))\n",
+        "\n",
+        "print(\"source_batch:\", source_tensor.shape)\n",
+        "print(source_tensor)\n",
+        "\n",
+        "print(\"target_batch:\", target_tensor.shape)\n",
+        "print(target_tensor)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "YWxod3OkUXsc",
+        "outputId": "50dd3bd8-4f3d-48b8-cbd8-be94550f8dfc"
+      },
+      "execution_count": 6,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "(source, target):\n",
+            "('Eine Gruppe von Männern lädt Baumwolle auf einen Lastwagen', 'A group of men are loading cotton onto a truck')\n",
+            "source_batch: torch.Size([35, 128])\n",
+            "tensor([[   2,    2,    2,  ...,    2,    2,    2],\n",
+            "        [  14,    5,    5,  ...,    5,   21,    5],\n",
+            "        [  38,   12,   35,  ...,   12, 1750,   69],\n",
+            "        ...,\n",
+            "        [   1,    1,    1,  ...,    1,    1,    1],\n",
+            "        [   1,    1,    1,  ...,    1,    1,    1],\n",
+            "        [   1,    1,    1,  ...,    1,    1,    1]])\n",
+            "target_batch: torch.Size([30, 128])\n",
+            "tensor([[   2,    2,    2,  ...,    2,    2,    2],\n",
+            "        [   6,    6,    6,  ...,  250,   19,    6],\n",
+            "        [  39,   12,   35,  ...,   12, 3254,   61],\n",
+            "        ...,\n",
+            "        [   1,    1,    1,  ...,    1,    1,    1],\n",
+            "        [   1,    1,    1,  ...,    1,    1,    1],\n",
+            "        [   1,    1,    1,  ...,    1,    1,    1]])\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "/usr/local/lib/python3.11/dist-packages/torch/utils/data/datapipes/iter/combining.py:337: UserWarning: Some child DataPipes are not exhausted when __iter__ is called. We are resetting the buffer and each child DataPipe will read from the start again.\n",
+            "  warnings.warn(\"Some child DataPipes are not exhausted when __iter__ is called. We are resetting \"\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#어텐션 마스크 생성\n",
+        "def generate_square_subsequent_mask(s):\n",
+        "    mask=(torch.triu(torch.ones((s, s), device=DEVICE))==1).transpose(0, 1)\n",
+        "    mask=(\n",
+        "        mask.float()\n",
+        "        .masked_fill(mask==0, float(\"-inf\"))\n",
+        "        .masked_fill(mask==1, float(0.0))\n",
+        "    )\n",
+        "    return mask\n",
+        "\n",
+        "def create_mask(src, tgt):\n",
+        "    src_seq_len=src.shape[0]\n",
+        "    tgt_seq_len=tgt.shape[0]\n",
+        "\n",
+        "    tgt_mask=generate_square_subsequent_mask(tgt_seq_len)\n",
+        "    src_mask=torch.zeros((src_seq_len, src_seq_len), device=DEVICE).type(torch.bool)\n",
+        "\n",
+        "    src_padding_mask=(src==PAD_IDX).transpose(0, 1)\n",
+        "    tgt_padding_mask=(tgt==PAD_IDX).transpose(0, 1)\n",
+        "    return src_mask, tgt_mask, src_padding_mask, tgt_padding_mask\n",
+        "\n",
+        "target_input=target_tensor[:-1, :]\n",
+        "target_out=target_tensor[1:, :]\n",
+        "\n",
+        "source_mask, target_mask, source_padding_mask, target_padding_mask=create_mask(\n",
+        "    source_tensor, target_input\n",
+        ")\n",
+        "\n",
+        "print(\"source_mask:\", source_mask.shape)\n",
+        "print(source_mask)\n",
+        "print(\"target_mask:\", target_mask.shape)\n",
+        "print(target_mask)\n",
+        "print(\"source_padding_mask:\", source_padding_mask.shape)\n",
+        "print(source_padding_mask)\n",
+        "print(\"target_padding_mask:\", target_padding_mask.shape)\n",
+        "print(target_padding_mask)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "92n_LBnvWzKs",
+        "outputId": "286a28b2-dd2d-4ca3-fa26-260bd8674922"
+      },
+      "execution_count": 7,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "source_mask: torch.Size([35, 35])\n",
+            "tensor([[False, False, False,  ..., False, False, False],\n",
+            "        [False, False, False,  ..., False, False, False],\n",
+            "        [False, False, False,  ..., False, False, False],\n",
+            "        ...,\n",
+            "        [False, False, False,  ..., False, False, False],\n",
+            "        [False, False, False,  ..., False, False, False],\n",
+            "        [False, False, False,  ..., False, False, False]])\n",
+            "target_mask: torch.Size([29, 29])\n",
+            "tensor([[0., -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, -inf],\n",
+            "        [0., 0., -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, -inf],\n",
+            "        [0., 0., 0., -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, -inf],\n",
+            "        [0., 0., 0., 0., -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, -inf],\n",
+            "        [0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf,\n",
+            "         -inf, -inf, -inf, -inf, -inf],\n",
+            "        [0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf,\n",
+            "         -inf, -inf, -inf, -inf, -inf],\n",
+            "        [0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf,\n",
+            "         -inf, -inf, -inf, -inf, -inf],\n",
+            "        [0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf,\n",
+            "         -inf, -inf, -inf, -inf, -inf],\n",
+            "        [0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf,\n",
+            "         -inf, -inf, -inf, -inf, -inf],\n",
+            "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf,\n",
+            "         -inf, -inf, -inf, -inf, -inf],\n",
+            "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf,\n",
+            "         -inf, -inf, -inf, -inf, -inf],\n",
+            "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf,\n",
+            "         -inf, -inf, -inf, -inf, -inf],\n",
+            "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf,\n",
+            "         -inf, -inf, -inf, -inf, -inf],\n",
+            "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf,\n",
+            "         -inf, -inf, -inf, -inf, -inf],\n",
+            "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf,\n",
+            "         -inf, -inf, -inf, -inf, -inf],\n",
+            "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf,\n",
+            "         -inf, -inf, -inf, -inf, -inf],\n",
+            "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf,\n",
+            "         -inf, -inf, -inf, -inf, -inf],\n",
+            "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf,\n",
+            "         -inf, -inf, -inf, -inf, -inf],\n",
+            "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf,\n",
+            "         -inf, -inf, -inf, -inf, -inf],\n",
+            "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf,\n",
+            "         -inf, -inf, -inf, -inf, -inf],\n",
+            "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf,\n",
+            "         -inf, -inf, -inf, -inf, -inf],\n",
+            "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf,\n",
+            "         -inf, -inf, -inf, -inf, -inf],\n",
+            "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf,\n",
+            "         -inf, -inf, -inf, -inf, -inf],\n",
+            "        [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",
+            "         -inf, -inf, -inf, -inf, -inf],\n",
+            "        [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., -inf, -inf, -inf, -inf],\n",
+            "        [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., -inf, -inf, -inf],\n",
+            "        [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., -inf, -inf],\n",
+            "        [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., -inf],\n",
+            "        [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",
+            "source_padding_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",
+            "target_padding_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"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#모델 학습 및 평가\n",
+        "'''\n",
+        "def run(model, optimizer, criterion, split):\n",
+        "    model.train() if split==\"train\" else model.eval()\n",
+        "    data_iter=Multi30k(split=split, language_pair=(SRC_LANGUAGE, TGT_LANGUAGE))\n",
+        "    dataloader=DataLoader(data_iter, batch_size=BATCH_SIZE, collate_fn=collator)\n",
+        "\n",
+        "    losses=0\n",
+        "    for source_batch, target_batch in dataloader:\n",
+        "        source_batch=source_batch.to(DEVICE)\n",
+        "        target_batch=target_batch.to(DEVICE)\n",
+        "\n",
+        "        target_input=target_batch[:-1, :]\n",
+        "        target_output=target_batch[1:, :]\n",
+        "\n",
+        "        src_mask, tgt_mask, src_padding_mask, tgt_padding_mask=create_mask(\n",
+        "            source_batch, target_input\n",
+        "        )\n",
+        "\n",
+        "        logits=model(\n",
+        "            src=source_batch,\n",
+        "            trg=target_input,\n",
+        "            src_mask=src_mask,\n",
+        "            tgt_mask=tgt_mask,\n",
+        "            src_padding_mask=src_padding_mask,\n",
+        "            tgt_padding_mask=tgt_padding_mask,\n",
+        "            memory_key_padding_mask=src_padding_mask,\n",
+        "        )\n",
+        "\n",
+        "        optimizer.zero_grad()\n",
+        "        loss=criterion(logits.reshape(-1, logits.shape[-1]), target_output.reshape(-1))\n",
+        "        if split==\"train\":\n",
+        "            loss.backward()\n",
+        "            optimizer.step()\n",
+        "        losses += loss.item()\n",
+        "\n",
+        "    return losses / len(list(dataloader))\n",
+        "\n",
+        "for epoch in range(5):\n",
+        "    train_loss=run(model, optimizer, criterion, \"train\")\n",
+        "    valid_loss=run(model, optimizer, criterion, \"valid\")\n",
+        "    print(f\"Epoch: {epoch+1}, Train loss: {train_loss:.3f}, Valid loss: {valid_loss:.3f}\")\n",
+        "'''"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 123
+        },
+        "id": "C7_ssU4bYycr",
+        "outputId": "ba4936f0-461e-4f95-e5cd-2ee26d116cf0"
+      },
+      "execution_count": 9,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "'\\ndef run(model, optimizer, criterion, split):\\n    model.train() if split==\"train\" else model.eval()\\n    data_iter=Multi30k(split=split, language_pair=(SRC_LANGUAGE, TGT_LANGUAGE))\\n    dataloader=DataLoader(data_iter, batch_size=BATCH_SIZE, collate_fn=collator)\\n\\n    losses=0\\n    for source_batch, target_batch in dataloader:\\n        source_batch=source_batch.to(DEVICE)\\n        target_batch=target_batch.to(DEVICE)\\n\\n        target_input=target_batch[:-1, :]\\n        target_output=target_batch[1:, :]\\n\\n        src_mask, tgt_mask, src_padding_mask, tgt_padding_mask=create_mask(\\n            source_batch, target_input\\n        )\\n\\n        logits=model(\\n            src=source_batch,\\n            trg=target_input,\\n            src_mask=src_mask,\\n            tgt_mask=tgt_mask,\\n            src_padding_mask=src_padding_mask,\\n            tgt_padding_mask=tgt_padding_mask,\\n            memory_key_padding_mask=src_padding_mask,\\n        )\\n\\n        optimizer.zero_grad()\\n        loss=criterion(logits.reshape(-1, logits.shape[-1]), target_output.reshape(-1))\\n        if split==\"train\":\\n            loss.backward()\\n            optimizer.step()\\n        losses += loss.item()\\n\\n    return losses / len(list(dataloader))\\n\\nfor epoch in range(5):\\n    train_loss=run(model, optimizer, criterion, \"train\")\\n    valid_loss=run(model, optimizer, criterion, \"valid\")\\n    print(f\"Epoch: {epoch+1}, Train loss: {train_loss:.3f}, Valid loss: {valid_loss:.3f}\")\\n'"
+            ],
+            "application/vnd.google.colaboratory.intrinsic+json": {
+              "type": "string"
+            }
+          },
+          "metadata": {},
+          "execution_count": 9
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#트랜스포머 모델 번역 결과\n",
+        "'''\n",
+        "def greedy_decode(model, source_tensor, source_mask, max_len, start_symbol):\n",
+        "    source_tensor=source_tensor.to(DEVICE)\n",
+        "    source_mask=source_mask.to(DEVICE)\n",
+        "\n",
+        "    memory=model.encode(source_tensor, source_mask)\n",
+        "    ys=torch.ones(1, 1).fill_(start_symbol).type(torch.long).to(DEVICE)\n",
+        "    for i in range(max_len - 1):\n",
+        "        memory=memory.to(DEVICE)\n",
+        "        target_mask=generate_square_subsequent_mask(ys.size(0))\n",
+        "        target_mask=target_mask.type(torch.bool).to(DEVICE)\n",
+        "\n",
+        "        out=model.decode(ys, memory, target_mask)\n",
+        "        out=out.transpose(0, 1)\n",
+        "        prob=model.generator(out[:, -1])\n",
+        "        _, next_word=torch.max(prob, dim=1)\n",
+        "        next_word=next_word.item()\n",
+        "\n",
+        "        ys=torch.cat(\n",
+        "            [ys, torch.ones(1, 1).type_as(source_tensor.data).fill_(next_word)], dim=0\n",
+        "        )\n",
+        "        if next_word==EOS_IDX:\n",
+        "            break\n",
+        "    return ys\n",
+        "\n",
+        "def translate(model, source_sentence):\n",
+        "    model.eval()\n",
+        "    source_tensor=text_transform[SRC_LANGUAGE](source_sentence).view(-1, 1)\n",
+        "    num_tokens=source_tensor.shape[0]\n",
+        "    src_mask=(torch.zeros(num_tokens, num_tokens)).type(torch.bool)\n",
+        "    tgt_tokens=greedy_decode(\n",
+        "        model, source_tensor, src_mask, max_len=num_tokens + 5, start_symbol=BOS_IDX\n",
+        "    ).flatten()\n",
+        "    output=vocab_transform[TGT_LANGUAGE].lookup_tokens(list(tgt_tokens.cpu().numpy()))[1:-1]\n",
+        "    return \" \".join(output)\n",
+        "\n",
+        "output_oov=translate(model, \"Eine Gruppe von Menschen steht vor einem Iglu .\")\n",
+        "output=translate(model, \"Eine Gruppe von Menschen steht vor einem Gebäude .\")\n",
+        "print(output_oov)\n",
+        "print(output)\n",
+        "'''"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 123
+        },
+        "id": "IBEFEM3Ka-IV",
+        "outputId": "ca87f515-d44d-41c5-c6d9-7715c3d86151"
+      },
+      "execution_count": 10,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "'\\ndef greedy_decode(model, source_tensor, source_mask, max_len, start_symbol):\\n    source_tensor=source_tensor.to(DEVICE)\\n    source_mask=source_mask.to(DEVICE)\\n\\n    memory=model.encode(source_tensor, source_mask)\\n    ys=torch.ones(1, 1).fill_(start_symbol).type(torch.long).to(DEVICE)\\n    for i in range(max_len - 1):\\n        memory=memory.to(DEVICE)\\n        target_mask=generate_square_subsequent_mask(ys.size(0))\\n        target_mask=target_mask.type(torch.bool).to(DEVICE)\\n    \\n        out=model.decode(ys, memory, target_mask)\\n        out=out.transpose(0, 1)\\n        prob=model.generator(out[:, -1])\\n        _, next_word=torch.max(prob, dim=1)\\n        next_word=next_word.item()\\n\\n        ys=torch.cat(\\n            [ys, torch.ones(1, 1).type_as(source_tensor.data).fill_(next_word)], dim=0\\n        )\\n        if next_word==EOS_IDX:\\n            break\\n    return ys\\n\\ndef translate(model, source_sentence):\\n    model.eval()\\n    source_tensor=text_transform[SRC_LANGUAGE](source_sentence).view(-1, 1)\\n    num_tokens=source_tensor.shape[0]\\n    src_mask=(torch.zeros(num_tokens, num_tokens)).type(torch.bool)\\n    tgt_tokens=greedy_decode(\\n        model, source_tensor, src_mask, max_len=num_tokens + 5, start_symbol=BOS_IDX\\n    ).flatten()\\n    output=vocab_transform[TGT_LANGUAGE].lookup_tokens(list(tgt_tokens.cpu().numpy()))[1:-1]\\n    return \" \".join(output)\\n\\noutput_oov=translate(model, \"Eine Gruppe von Menschen steht vor einem Iglu .\")\\noutput=translate(model, \"Eine Gruppe von Menschen steht vor einem Gebäude .\")\\nprint(output_oov)\\nprint(output)\\n'"
+            ],
+            "application/vnd.google.colaboratory.intrinsic+json": {
+              "type": "string"
+            }
+          },
+          "metadata": {},
+          "execution_count": 10
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**GPT**"
+      ],
+      "metadata": {
+        "id": "CPVbpmVZb5oG"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!pip uninstall transformers -y\n",
+        "!pip uninstall torchao -y\n",
+        "!pip uninstall accelerate -y\n",
+        "!pip install transformers==4.38.2"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 791
+        },
+        "id": "ECNs9EyciqfQ",
+        "outputId": "20752d40-0f48-471b-b2fd-068dde63ac62"
+      },
+      "execution_count": 2,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Found existing installation: transformers 4.52.3\n",
+            "Uninstalling transformers-4.52.3:\n",
+            "  Successfully uninstalled transformers-4.52.3\n",
+            "\u001b[33mWARNING: Skipping torchao as it is not installed.\u001b[0m\u001b[33m\n",
+            "\u001b[0m\u001b[33mWARNING: Skipping accelerate as it is not installed.\u001b[0m\u001b[33m\n",
+            "\u001b[0mCollecting transformers==4.38.2\n",
+            "  Downloading transformers-4.38.2-py3-none-any.whl.metadata (130 kB)\n",
+            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m130.7/130.7 kB\u001b[0m \u001b[31m3.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hRequirement already satisfied: filelock in /usr/local/lib/python3.11/dist-packages (from transformers==4.38.2) (3.18.0)\n",
+            "Requirement already satisfied: huggingface-hub<1.0,>=0.19.3 in /usr/local/lib/python3.11/dist-packages (from transformers==4.38.2) (0.31.2)\n",
+            "Requirement already satisfied: numpy>=1.17 in /usr/local/lib/python3.11/dist-packages (from transformers==4.38.2) (2.0.2)\n",
+            "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.11/dist-packages (from transformers==4.38.2) (24.2)\n",
+            "Requirement already satisfied: pyyaml>=5.1 in /usr/local/lib/python3.11/dist-packages (from transformers==4.38.2) (6.0.2)\n",
+            "Requirement already satisfied: regex!=2019.12.17 in /usr/local/lib/python3.11/dist-packages (from transformers==4.38.2) (2024.11.6)\n",
+            "Requirement already satisfied: requests in /usr/local/lib/python3.11/dist-packages (from transformers==4.38.2) (2.32.3)\n",
+            "Collecting tokenizers<0.19,>=0.14 (from transformers==4.38.2)\n",
+            "  Downloading tokenizers-0.15.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (6.7 kB)\n",
+            "Requirement already satisfied: safetensors>=0.4.1 in /usr/local/lib/python3.11/dist-packages (from transformers==4.38.2) (0.5.3)\n",
+            "Requirement already satisfied: tqdm>=4.27 in /usr/local/lib/python3.11/dist-packages (from transformers==4.38.2) (4.67.1)\n",
+            "Requirement already satisfied: fsspec>=2023.5.0 in /usr/local/lib/python3.11/dist-packages (from huggingface-hub<1.0,>=0.19.3->transformers==4.38.2) (2025.3.2)\n",
+            "Requirement already satisfied: typing-extensions>=3.7.4.3 in /usr/local/lib/python3.11/dist-packages (from huggingface-hub<1.0,>=0.19.3->transformers==4.38.2) (4.13.2)\n",
+            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.11/dist-packages (from requests->transformers==4.38.2) (3.4.2)\n",
+            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.11/dist-packages (from requests->transformers==4.38.2) (3.10)\n",
+            "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.11/dist-packages (from requests->transformers==4.38.2) (2.4.0)\n",
+            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.11/dist-packages (from requests->transformers==4.38.2) (2025.4.26)\n",
+            "Downloading transformers-4.38.2-py3-none-any.whl (8.5 MB)\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m8.5/8.5 MB\u001b[0m \u001b[31m63.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hDownloading tokenizers-0.15.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (3.6 MB)\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m3.6/3.6 MB\u001b[0m \u001b[31m85.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hInstalling collected packages: tokenizers, transformers\n",
+            "  Attempting uninstall: tokenizers\n",
+            "    Found existing installation: tokenizers 0.21.1\n",
+            "    Uninstalling tokenizers-0.21.1:\n",
+            "      Successfully uninstalled tokenizers-0.21.1\n",
+            "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n",
+            "peft 0.15.2 requires accelerate>=0.21.0, which is not installed.\n",
+            "sentence-transformers 4.1.0 requires transformers<5.0.0,>=4.41.0, but you have transformers 4.38.2 which is incompatible.\n",
+            "torchtune 0.6.1 requires torchdata==0.11.0, but you have torchdata 0.7.1 which is incompatible.\u001b[0m\u001b[31m\n",
+            "\u001b[0mSuccessfully installed tokenizers-0.15.2 transformers-4.38.2\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "application/vnd.colab-display-data+json": {
+              "pip_warning": {
+                "packages": [
+                  "transformers"
+                ]
+              },
+              "id": "f0e8f4b8126d467a890d0f8a4c9d3f55"
+            }
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#문장 생성을 위한 GPT-2 모델의 구조\n",
+        "from transformers import GPT2LMHeadModel\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(\"L\", sub_name)\n",
+        "        for ssub_name, ssub_module in sub_module.named_children():\n",
+        "            print(\"| L\", ssub_name)\n",
+        "            for sssub_name, sssub_module in ssub_module.named_children():\n",
+        "                print(\"| | L\", sssub_name)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000,
+          "referenced_widgets": [
+            "e737566dd38d46ab9a9ef1536f5d05aa",
+            "1a0e342718814cca94c1b012a913b5cb",
+            "92030f5fc71e411c88dbe59fde8a8943",
+            "27ff19d5432d406d95570656be644317",
+            "b5daf02a1cd94b0aa36e90619011c242",
+            "32d954eaa6f64d26876acff25f3cad7e",
+            "02da3c36eea648209ebf3a3ff3f5b663",
+            "37fbc1a3e5d344359599dac23c66c100",
+            "197bb669140543638089a414068c26f8",
+            "0c01df79d1fc4fdc949f895a02f51b51",
+            "6a8796241b4e4e95ac1cc4c3c37eef42",
+            "fa374ff8b9654558aaac536e6b1080b6",
+            "2796fa85c834469ca893bf1cc6c9267f",
+            "3adea502b9ce4440a4d1368c30b723a8",
+            "782dcc37e6cf4a40852955dba44cce86",
+            "0c1e4d3b2633458f87f6c89f8d8241c3",
+            "ef4503c9475047bfb41215cfbb9e58d8",
+            "5b63f473766a4f34ac4a9c433b89b00f",
+            "24f21c8c117840cf8b4771f03d4bfe4e",
+            "595ab61151fa4ad490d27c1cf80b76c8",
+            "86203ca640604c45896e54528289953f",
+            "6766bdc5fa6c4741a6ba4d8e958c625b",
+            "b59c28e374f8440cb92b6be3f700daaa",
+            "ce63c96a73ce4f43aa5ac20f3897ed6a",
+            "c4cc797911f94208b6be8caed9479755",
+            "4e6f54a6942946fcb2ef20a34a162d63",
+            "633a97c65c374a49b0aefe326a00c32f",
+            "991c897bdd4e47d98469121f14acce5a",
+            "b5238fc40bbc4b6392ce14bda84e1fa6",
+            "3f97c2dac5894369be88de9a7f22ddc1",
+            "04455aa7edb64e3093fc2c029b17af6c",
+            "d9678ea535104a10be6abcb5c1e17dcd",
+            "4be5388615a0484caa89d191779cb0d5"
+          ]
+        },
+        "id": "4TXAf-XIeeUy",
+        "outputId": "21b17e58-b90c-4159-9e52-472f50022f61"
+      },
+      "execution_count": 1,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "\n",
+            "A module that was compiled using NumPy 1.x cannot be run in\n",
+            "NumPy 2.0.2 as it may crash. To support both 1.x and 2.x\n",
+            "versions of NumPy, modules must be compiled with NumPy 2.0.\n",
+            "Some module may need to rebuild instead e.g. with 'pybind11>=2.12'.\n",
+            "\n",
+            "If you are a user of the module, the easiest solution will be to\n",
+            "downgrade to 'numpy<2' or try to upgrade the affected module.\n",
+            "We expect that some modules will need time to support NumPy 2.\n",
+            "\n",
+            "Traceback (most recent call last):  File \"<frozen runpy>\", line 198, in _run_module_as_main\n",
+            "  File \"<frozen runpy>\", line 88, in _run_code\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/colab_kernel_launcher.py\", line 37, in <module>\n",
+            "    ColabKernelApp.launch_instance()\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/traitlets/config/application.py\", line 992, in launch_instance\n",
+            "    app.start()\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/ipykernel/kernelapp.py\", line 712, in start\n",
+            "    self.io_loop.start()\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/tornado/platform/asyncio.py\", line 205, in start\n",
+            "    self.asyncio_loop.run_forever()\n",
+            "  File \"/usr/lib/python3.11/asyncio/base_events.py\", line 608, in run_forever\n",
+            "    self._run_once()\n",
+            "  File \"/usr/lib/python3.11/asyncio/base_events.py\", line 1936, in _run_once\n",
+            "    handle._run()\n",
+            "  File \"/usr/lib/python3.11/asyncio/events.py\", line 84, in _run\n",
+            "    self._context.run(self._callback, *self._args)\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/ipykernel/kernelbase.py\", line 510, in dispatch_queue\n",
+            "    await self.process_one()\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/ipykernel/kernelbase.py\", line 499, in process_one\n",
+            "    await dispatch(*args)\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/ipykernel/kernelbase.py\", line 406, in dispatch_shell\n",
+            "    await result\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/ipykernel/kernelbase.py\", line 730, in execute_request\n",
+            "    reply_content = await reply_content\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/ipykernel/ipkernel.py\", line 383, in do_execute\n",
+            "    res = shell.run_cell(\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/ipykernel/zmqshell.py\", line 528, in run_cell\n",
+            "    return super().run_cell(*args, **kwargs)\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/IPython/core/interactiveshell.py\", line 2975, in run_cell\n",
+            "    result = self._run_cell(\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/IPython/core/interactiveshell.py\", line 3030, in _run_cell\n",
+            "    return runner(coro)\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/IPython/core/async_helpers.py\", line 78, in _pseudo_sync_runner\n",
+            "    coro.send(None)\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/IPython/core/interactiveshell.py\", line 3257, in run_cell_async\n",
+            "    has_raised = await self.run_ast_nodes(code_ast.body, cell_name,\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/IPython/core/interactiveshell.py\", line 3473, in run_ast_nodes\n",
+            "    if (await self.run_code(code, result,  async_=asy)):\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/IPython/core/interactiveshell.py\", line 3553, in run_code\n",
+            "    exec(code_obj, self.user_global_ns, self.user_ns)\n",
+            "  File \"<ipython-input-1-39195a8cb007>\", line 2, in <cell line: 0>\n",
+            "    from transformers import GPT2LMHeadModel\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/transformers/__init__.py\", line 26, in <module>\n",
+            "    from . import dependency_versions_check\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/transformers/dependency_versions_check.py\", line 16, in <module>\n",
+            "    from .utils.versions import require_version, require_version_core\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/transformers/utils/__init__.py\", line 33, in <module>\n",
+            "    from .generic import (\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/transformers/utils/generic.py\", line 442, in <module>\n",
+            "    import torch.utils._pytree as _torch_pytree\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/torch/__init__.py\", line 1471, in <module>\n",
+            "    from .functional import *  # noqa: F403\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/torch/functional.py\", line 9, in <module>\n",
+            "    import torch.nn.functional as F\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/torch/nn/__init__.py\", line 1, in <module>\n",
+            "    from .modules import *  # noqa: F403\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/torch/nn/modules/__init__.py\", line 35, in <module>\n",
+            "    from .transformer import TransformerEncoder, TransformerDecoder, \\\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/torch/nn/modules/transformer.py\", line 20, in <module>\n",
+            "    device: torch.device = torch.device(torch._C._get_default_device()),  # torch.device('cpu'),\n",
+            "/usr/local/lib/python3.11/dist-packages/torch/nn/modules/transformer.py:20: UserWarning: Failed to initialize NumPy: _ARRAY_API not found (Triggered internally at ../torch/csrc/utils/tensor_numpy.cpp:84.)\n",
+            "  device: torch.device = torch.device(torch._C._get_default_device()),  # torch.device('cpu'),\n",
+            "/usr/local/lib/python3.11/dist-packages/huggingface_hub/file_download.py:943: FutureWarning: `resume_download` is deprecated and will be removed in version 1.0.0. Downloads always resume when possible. If you want to force a new download, use `force_download=True`.\n",
+            "  warnings.warn(\n",
+            "/usr/local/lib/python3.11/dist-packages/huggingface_hub/utils/_auth.py:94: UserWarning: \n",
+            "The secret `HF_TOKEN` does not exist in your Colab secrets.\n",
+            "To authenticate with the Hugging Face Hub, create a token in your settings tab (https://huggingface.co/settings/tokens), set it as secret in your Google Colab and restart your session.\n",
+            "You will be able to reuse this secret in all of your notebooks.\n",
+            "Please note that authentication is recommended but still optional to access public models or datasets.\n",
+            "  warnings.warn(\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "config.json:   0%|          | 0.00/665 [00:00<?, ?B/s]"
+            ],
+            "application/vnd.jupyter.widget-view+json": {
+              "version_major": 2,
+              "version_minor": 0,
+              "model_id": "e737566dd38d46ab9a9ef1536f5d05aa"
+            }
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "Xet Storage is enabled for this repo, but the 'hf_xet' package is not installed. Falling back to regular HTTP download. For better performance, install the package with: `pip install huggingface_hub[hf_xet]` or `pip install hf_xet`\n",
+            "WARNING:huggingface_hub.file_download:Xet Storage is enabled for this repo, but the 'hf_xet' package is not installed. Falling back to regular HTTP download. For better performance, install the package with: `pip install huggingface_hub[hf_xet]` or `pip install hf_xet`\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "model.safetensors:   0%|          | 0.00/548M [00:00<?, ?B/s]"
+            ],
+            "application/vnd.jupyter.widget-view+json": {
+              "version_major": 2,
+              "version_minor": 0,
+              "model_id": "fa374ff8b9654558aaac536e6b1080b6"
+            }
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "generation_config.json:   0%|          | 0.00/124 [00:00<?, ?B/s]"
+            ],
+            "application/vnd.jupyter.widget-view+json": {
+              "version_major": 2,
+              "version_minor": 0,
+              "model_id": "b59c28e374f8440cb92b6be3f700daaa"
+            }
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "transformer\n",
+            "L wte\n",
+            "L wpe\n",
+            "L drop\n",
+            "L h\n",
+            "| L 0\n",
+            "| | L ln_1\n",
+            "| | L attn\n",
+            "| | L ln_2\n",
+            "| | L mlp\n",
+            "| L 1\n",
+            "| | L ln_1\n",
+            "| | L attn\n",
+            "| | L ln_2\n",
+            "| | L mlp\n",
+            "| L 2\n",
+            "| | L ln_1\n",
+            "| | L attn\n",
+            "| | L ln_2\n",
+            "| | L mlp\n",
+            "| L 3\n",
+            "| | L ln_1\n",
+            "| | L attn\n",
+            "| | L ln_2\n",
+            "| | L mlp\n",
+            "| L 4\n",
+            "| | L ln_1\n",
+            "| | L attn\n",
+            "| | L ln_2\n",
+            "| | L mlp\n",
+            "| L 5\n",
+            "| | L ln_1\n",
+            "| | L attn\n",
+            "| | L ln_2\n",
+            "| | L mlp\n",
+            "| L 6\n",
+            "| | L ln_1\n",
+            "| | L attn\n",
+            "| | L ln_2\n",
+            "| | L mlp\n",
+            "| L 7\n",
+            "| | L ln_1\n",
+            "| | L attn\n",
+            "| | L ln_2\n",
+            "| | L mlp\n",
+            "| L 8\n",
+            "| | L ln_1\n",
+            "| | L attn\n",
+            "| | L ln_2\n",
+            "| | L mlp\n",
+            "| L 9\n",
+            "| | L ln_1\n",
+            "| | L attn\n",
+            "| | L ln_2\n",
+            "| | L mlp\n",
+            "| L 10\n",
+            "| | L ln_1\n",
+            "| | L attn\n",
+            "| | L ln_2\n",
+            "| | L mlp\n",
+            "| L 11\n",
+            "| | L ln_1\n",
+            "| | L attn\n",
+            "| | L ln_2\n",
+            "| | L mlp\n",
+            "L ln_f\n",
+            "lm_head\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#GPT-2를 이용한 문장 생성\n",
+        "'''\n",
+        "from transformers import pipeline\n",
+        "\n",
+        "generator=pipeline(task=\"text-generation\", model=\"gpt2\", device=-1)\n",
+        "outputs=generator(\n",
+        "    text_inputs=\"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",
+        "'''"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 52
+        },
+        "id": "fmfhlWNXjXR-",
+        "outputId": "b7747e47-4b1d-46e1-d35e-d567f0330d69"
+      },
+      "execution_count": 3,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "'\\nfrom transformers import pipeline\\n\\ngenerator=pipeline(task=\"text-generation\", model=\"gpt2\", device=-1)\\noutputs=generator(\\n    text_inputs=\"Machine learning is\",\\n    max_length=20,\\n    num_return_sequences=3,\\n    pad_token_id=generator.tokenizer.eos_token_id,\\n)\\nprint(outputs)\\n'"
+            ],
+            "application/vnd.google.colaboratory.intrinsic+json": {
+              "type": "string"
+            }
+          },
+          "metadata": {},
+          "execution_count": 3
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#CoLA 데이터세트 불러오기\n",
+        "import torch\n",
+        "from torchtext.datasets import CoLA\n",
+        "from transformers import AutoTokenizer\n",
+        "from torch.utils.data import DataLoader\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",
+        "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))"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "yl4tLswqjXQB",
+        "outputId": "d44fdefe-d9f5-468c-8e78-dfdcd4bb7e78"
+      },
+      "execution_count": 4,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Train Dataset Length : 8550\n",
+            "Valid Dataset Length : 526\n",
+            "Test Dataset Length : 515\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#GPT-2 모델 설정\n",
+        "from torch import optim\n",
+        "from transformers import GPT2ForSequenceClassification\n",
+        "\n",
+        "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",
+        "optimizer=optim.Adam(model.parameters(), lr=5e-5)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "XMX7zjY9mzly",
+        "outputId": "2e31a149-55a2-44b1-e43b-93f9578e5414"
+      },
+      "execution_count": 5,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "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"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#GPT-2 모델 학습 및 검증\n",
+        "'''\n",
+        "import numpy as np\n",
+        "from torch import nn\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",
+        "        criterion=nn.CrossEntropyLoss()\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",
+        "\n",
+        "            loss=criterion(logits, labels)\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\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(), \"../GPT2ForSequenceClassification.pt\")\n",
+        "        print(\"Saved the model weights\")\n",
+        "'''"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 123
+        },
+        "id": "KsyYikTknFZm",
+        "outputId": "b4a504f7-8026-482b-d74f-8675aec621c2"
+      },
+      "execution_count": 9,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "'\\nimport numpy as np\\nfrom torch import nn\\n\\ndef 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\\ndef 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\\ndef evaluation(model, dataloader):\\n    with torch.no_grad():\\n        model.eval()\\n        criterion=nn.CrossEntropyLoss()\\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\\n            loss=criterion(logits, labels)\\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\\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\\nbest_loss=10000\\nfor 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(), \"../GPT2ForSequenceClassification.pt\")\\n        print(\"Saved the model weights\")\\n'"
+            ],
+            "application/vnd.google.colaboratory.intrinsic+json": {
+              "type": "string"
+            }
+          },
+          "metadata": {},
+          "execution_count": 9
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#모델 평가\n",
+        "'''\n",
+        "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(\"../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}\")\n",
+        "'''"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 70
+        },
+        "id": "oEhsEXA-n60N",
+        "outputId": "d9836dce-f04f-4399-ad34-ec89aa0877a4"
+      },
+      "execution_count": 10,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "'\\nmodel=GPT2ForSequenceClassification.from_pretrained(\\n    pretrained_model_name_or_path=\"gpt2\",\\n    num_labels=2\\n).to(device)\\nmodel.config.pad_token_id=model.config.eos_token_id\\nmodel.load_state_dict(torch.load(\"../GPT2ForSequenceClassification.pt\"))\\n\\ntest_loss, test_accuracy=evaluation(model, test_dataloader)\\nprint(f\"Test Loss: {test_loss:.4f}\")\\nprint(f\"Test Accuracy: {test_accuracy:.4f}\")\\n'"
+            ],
+            "application/vnd.google.colaboratory.intrinsic+json": {
+              "type": "string"
+            }
+          },
+          "metadata": {},
+          "execution_count": 10
+        }
+      ]
+    }
+  ]
+}
\ No newline at end of file
diff --git "a/Week12_\354\230\210\354\212\265\352\263\274\354\240\234_\355\225\250\354\230\210\353\246\260.pdf" "b/Week12_\354\230\210\354\212\265\352\263\274\354\240\234_\355\225\250\354\230\210\353\246\260.pdf"
new file mode 100644
index 0000000..063e2d0
Binary files /dev/null and "b/Week12_\354\230\210\354\212\265\352\263\274\354\240\234_\355\225\250\354\230\210\353\246\260.pdf" differ