![\"Open](\"https://colab.research.google.com/assets/colab-badge.svg\"){kind=icon}
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2fe11c0f",
+ "metadata": {
+ "id": "2fe11c0f"
+ },
+ "source": [
+ "## 필요 라이브러리 import"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "bbebe731",
+ "metadata": {
+ "id": "bbebe731"
+ },
+ "outputs": [],
+ "source": [
+ "import numpy as np\n",
+ "import matplotlib.pyplot as plt\n",
+ "import tensorflow as tf"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5cd2132b",
+ "metadata": {
+ "id": "5cd2132b"
+ },
+ "source": [
+ "TypeError: Unable to convert function return value to a Python type! The signature was\n",
+ "\t() -> handle\n",
+ "- tensorflow를 import 할 때, 해당 오류가 발생하는 건 tensorflow 라이브러리 버전이 낮기 때문임.\n",
+ " - pip install --upgrade tensorflow\n",
+ " - pip uninstall tensorflow 하고서 pip install tensorflow 하기"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b9c7b06c",
+ "metadata": {
+ "id": "b9c7b06c"
+ },
+ "source": [
+ "ERROR: Could not install packages due to an OSError: [WinError 5] 액세스가 거부되었습니다: \n",
+ "- 해당 에러가 cmd 창에서 나타나는 경우, 다음 명령문을 conda install 전에 입력한다.\n",
+ " - conda config --set ssl_verify false\n",
+ " - conda install pip tensorflow"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "위의 방식대로 했는데도 안 됐음...\n",
+ "--> 근데 그냥... 코랩으로 돌리면 되는 거였음..."
+ ],
+ "metadata": {
+ "id": "mSVrStdeJrjB"
+ },
+ "id": "mSVrStdeJrjB"
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "92cc660a",
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 35
+ },
+ "id": "92cc660a",
+ "outputId": "d0cb368f-7bd3-4880-beac-acfea6e2db1e"
+ },
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "'2.12.0'"
+ ],
+ "application/vnd.google.colaboratory.intrinsic+json": {
+ "type": "string"
+ }
+ },
+ "metadata": {},
+ "execution_count": 4
+ }
+ ],
+ "source": [
+ "tf.__version__ #2.6.0 이상 버전에서 작업 진행 필요"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6f9aa344",
+ "metadata": {
+ "id": "6f9aa344"
+ },
+ "source": [
+ "## Positional Encoding 구현"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "d833813b",
+ "metadata": {
+ "id": "d833813b"
+ },
+ "outputs": [],
+ "source": [
+ "class PositionalEncoding(tf.keras.layers.Layer):\n",
+ " def __init__(self, position, d_model):\n",
+ " super(PositionalEncoding, self).__init__()\n",
+ " self.pos_encoding = self.positional_encoding(position, d_model)\n",
+ "\n",
+ " def get_angles(self, position, i, d_model):\n",
+ " angles = 1 / tf.pow(10000, (2 * (i // 2)) / tf.cast(d_model, tf.float32))\n",
+ " return position * angles\n",
+ "\n",
+ " def positional_encoding(self, position, d_model):\n",
+ " angle_rads = self.get_angles(\n",
+ " position=tf.range(position, dtype=tf.float32)[:, tf.newaxis],\n",
+ " i=tf.range(d_model, dtype=tf.float32)[tf.newaxis, :],\n",
+ " d_model=d_model)\n",
+ "\n",
+ " # 배열의 짝수 인덱스(2i)에는 사인 함수 적용\n",
+ " sines = tf.math.sin(angle_rads[:, 0::2])\n",
+ "\n",
+ " # 배열의 홀수 인덱스(2i+1)에는 코사인 함수 적용\n",
+ " cosines = tf.math.cos(angle_rads[:, 1::2])\n",
+ "\n",
+ " angle_rads = np.zeros(angle_rads.shape)\n",
+ " angle_rads[:, 0::2] = sines\n",
+ " angle_rads[:, 1::2] = cosines\n",
+ " pos_encoding = tf.constant(angle_rads)\n",
+ " pos_encoding = pos_encoding[tf.newaxis, ...]\n",
+ "\n",
+ " print(pos_encoding.shape)\n",
+ " return tf.cast(pos_encoding, tf.float32)\n",
+ "\n",
+ " def call(self, inputs):\n",
+ " return inputs + self.pos_encoding[:, :tf.shape(inputs)[1], :]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "026d42a0",
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 473
+ },
+ "id": "026d42a0",
+ "outputId": "650011ba-be03-4c83-d2fb-7135aea515d1"
+ },
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "(1, 50, 128)\n"
+ ]
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "text/plain": [
+ "| \n", + " | Q | \n", + "A | \n", + "label | \n", + "
|---|---|---|---|
| 0 | \n", + "12시 땡! | \n", + "하루가 또 가네요. | \n", + "0 | \n", + "
| 1 | \n", + "1지망 학교 떨어졌어 | \n", + "위로해 드립니다. | \n", + "0 | \n", + "
| 2 | \n", + "3박4일 놀러가고 싶다 | \n", + "여행은 언제나 좋죠. | \n", + "0 | \n", + "
| 3 | \n", + "3박4일 정도 놀러가고 싶다 | \n", + "여행은 언제나 좋죠. | \n", + "0 | \n", + "
| 4 | \n", + "PPL 심하네 | \n", + "눈살이 찌푸려지죠. | \n", + "0 | \n", + "
"
]
},
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## Transformer를 사용하는 데 쓰이는 라이브러리\n",
+ "- tensorflow(아래 구현 코드에서 확인 가능)\n",
+ "- pytorch\n",
+ "- huggingface transformers\n",
+ "- fairseq"
+ ],
+ "metadata": {
+ "id": "DXRgJAGiD0-Z"
+ },
+ "id": "DXRgJAGiD0-Z"
+ },
{
"cell_type": "markdown",
"id": "2fe11c0f",
@@ -22,7 +36,7 @@
},
{
"cell_type": "code",
- "execution_count": 3,
+ "execution_count": null,
"id": "bbebe731",
"metadata": {
"id": "bbebe731"
@@ -74,7 +88,7 @@
},
{
"cell_type": "code",
- "execution_count": 4,
+ "execution_count": null,
"id": "92cc660a",
"metadata": {
"colab": {
@@ -113,29 +127,51 @@
"## Positional Encoding 구현"
]
},
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Tensorflow 및 Keras에서 Positional Encoding 레이어를 정의하는 내용.\n",
+ "- transformer의 입력 시퀀스에 위치 인코딩을 추가해주는 역할\n",
+ " - 위치 인코딩 : 입력 시퀀스의 토큰 위치에 대한 정보를 모델에 제공하기 위해 사용되며, 이는 시퀀스의 순서와 문맥을 이해하는 데 중요함."
+ ],
+ "metadata": {
+ "id": "5mPnbVw6T50X"
+ },
+ "id": "5mPnbVw6T50X"
+ },
{
"cell_type": "code",
- "execution_count": 5,
+ "execution_count": null,
"id": "d833813b",
"metadata": {
"id": "d833813b"
},
"outputs": [],
"source": [
- "class PositionalEncoding(tf.keras.layers.Layer):\n",
- " def __init__(self, position, d_model):\n",
+ "class PositionalEncoding(tf.keras.layers.Layer): #tf.keras.layers.Layer를 상속받음\n",
+ " def __init__(self, position, d_model): \n",
+ " #position:입력시퀀스의 최대길이, d_model:입력 임베딩의 차원\n",
" super(PositionalEncoding, self).__init__()\n",
" self.pos_encoding = self.positional_encoding(position, d_model)\n",
"\n",
" def get_angles(self, position, i, d_model):\n",
+ " #모든 위치, 임베딩 차원에 대한 각도 배열 반환.\n",
+ " # i : 각도의 인덱스\n",
+ " ## 짝수면 2로 나뉘어져서 지수가 0 -> sin함수 쓸 때 사용되는 각도 생성\n",
+ " ## 홀수면 지수가 1 -> cos함수 쓸 때 사용되는 각도 생성\n",
" angles = 1 / tf.pow(10000, (2 * (i // 2)) / tf.cast(d_model, tf.float32))\n",
" return position * angles\n",
+ " # tf.pow : x^y\n",
+ " # tf.cast:배열의 데이터타입을 바꿔줌. 여기선 d_model을 float32형태로 변화.\n",
"\n",
" def positional_encoding(self, position, d_model):\n",
+ " \n",
+ " #get_angles 함수 : 인코딩할 단어 위치(position), 임베딩 차원(d_model),\n",
+ " #인덱스(i)에 따라 각도(angles) 계산함\n",
" angle_rads = self.get_angles(\n",
" position=tf.range(position, dtype=tf.float32)[:, tf.newaxis],\n",
" i=tf.range(d_model, dtype=tf.float32)[tf.newaxis, :],\n",
- " d_model=d_model)\n",
+ " d_model=d_model) \n",
"\n",
" # 배열의 짝수 인덱스(2i)에는 사인 함수 적용\n",
" sines = tf.math.sin(angle_rads[:, 0::2])\n",
@@ -143,22 +179,41 @@
" # 배열의 홀수 인덱스(2i+1)에는 코사인 함수 적용\n",
" cosines = tf.math.cos(angle_rads[:, 1::2])\n",
"\n",
- " angle_rads = np.zeros(angle_rads.shape)\n",
+ " angle_rads = np.zeros(angle_rads.shape) \n",
+ " #계산된 sines와 cosines를 이용해 각도 배열(angle_rads) 만듦\n",
" angle_rads[:, 0::2] = sines\n",
" angle_rads[:, 1::2] = cosines\n",
" pos_encoding = tf.constant(angle_rads)\n",
+ " #angle_rads 기반으로 pos_encoding 배열을 만듦\n",
+ " #이 배열은 angle_rads를 그대로 복사한 다음에, tf.newaxis로 차원을 추가하고\n",
" pos_encoding = pos_encoding[tf.newaxis, ...]\n",
"\n",
" print(pos_encoding.shape)\n",
+ " #tf.cast를 이용해 float32형태로 변경함\n",
" return tf.cast(pos_encoding, tf.float32)\n",
+ " #해당 배열의 모양은 (1=배치차원, position, d_model)임.\n",
+ " \n",
+ " '''\n",
+ " 딥러닝 모델 학습 시, 데이터셋은 일반적으로 미니배치(minibatch) 단위로 처리됨\n",
+ " 전체 데이터셋이 아닌 일부 데이터(ex. 32개의 이미지)를 한번에 모델에 입력하고, 그 출력을 이용해 모델을 학습시킴\n",
+ " 이렇게 모델에 입력되는 데이터의 묶음을 미니 배치라고 하며, 미니배치 단위로 \n",
+ " 처리하는 건 GPU를 비롯한 하드웨어의 병렬 처리 기능을 활용해 연산 속도를 높일 수 있음.\n",
"\n",
- " def call(self, inputs):\n",
- " return inputs + self.pos_encoding[:, :tf.shape(inputs)[1], :]"
+ " 배치 차원 = 미니 배치의 크기\n",
+ " 배열은 1개의 미니배치를 처리함.\n",
+ " '''\n",
+ "\n",
+ " def call(self, inputs): \n",
+ " #input sequence에 tensor 추가되고, \n",
+ " #브로드캐스팅을 사용해 위치 인코딩이 시퀀스의 올바른 부분에 추가되도록 보장함.\n",
+ " ## 브로드캐스팅 : NumPy 및 TensorFlow와 같은 배열/텐서 연산에서 자동으로 배열/텐서의 크기를 조정해 연산이 가능하도록 하는 기능\n",
+ " return inputs + self.pos_encoding[:, :tf.shape(inputs)[1], :]\n",
+ " ##self는 pos_encoding의 첫번째 차원인 배치 차원과 동일함."
]
},
{
"cell_type": "code",
- "execution_count": 6,
+ "execution_count": null,
"id": "026d42a0",
"metadata": {
"colab": {
@@ -189,6 +244,13 @@
],
"source": [
"sample_pos_encoding = PositionalEncoding(50, 128)\n",
+ "#아까 만든 클래스를 사용해서 생성한 sample_pos_encoding 배열을 시각화함.\n",
+ "\n",
+ "#pcolormesh : 2차원 배열을 시각화할 때 사용하며, 배열 값에 따라 색상을 적용해서 이미지 생성함.\n",
+ "\n",
+ "#sample_pos_encoding은 tensor 객체이므로, \n",
+ "#numpy 메소드를 사용해서 tensor를 numpy 배열로 변환한 다음\n",
+ "#[0]을 사용해서 (batch 차원, position, d_model)에서 인덱스 0인 batch 차원을 없앤 채로 반환함.\n",
"\n",
"plt.pcolormesh(sample_pos_encoding.pos_encoding.numpy()[0], cmap='RdBu')\n",
"plt.xlabel('Depth')\n",
@@ -210,7 +272,7 @@
},
{
"cell_type": "code",
- "execution_count": 7,
+ "execution_count": null,
"id": "efddecf0",
"metadata": {
"id": "efddecf0"
@@ -223,8 +285,9 @@
" # value 크기 : (batch_size, num_heads, value의 문장 길이, d_model/num_heads)\n",
" # padding_mask : (batch_size, 1, 1, key의 문장 길이)\n",
"\n",
- " # Q와 K의 곱. 어텐션 스코어 행렬.\n",
- " matmul_qk = tf.matmul(query, key, transpose_b=True)\n",
+ " # Q와 K의 곱. 어텐션 스코어 행렬. \n",
+ " matmul_qk = tf.matmul(query, key, transpose_b=True) \n",
+ " #'key'의 transpose를 사용해 key와 query의 dot product를 계산\n",
"\n",
" # 스케일링\n",
" # dk의 루트값으로 나눠준다.\n",
@@ -258,7 +321,7 @@
},
{
"cell_type": "code",
- "execution_count": 8,
+ "execution_count": null,
"id": "7618539d",
"metadata": {
"id": "7618539d"
@@ -272,7 +335,8 @@
" self.num_heads = num_heads\n",
" self.d_model = d_model\n",
"\n",
- " assert d_model % self.num_heads == 0\n",
+ " assert d_model % self.num_heads == 0 \n",
+ " #d_model을 num_heads로 나눈 값이 정확하게 나누어 떨어지는지 확인하는 용도\n",
"\n",
" # d_model을 num_heads로 나눈 값.\n",
" # 논문 기준 : 64\n",
@@ -293,6 +357,17 @@
" return tf.transpose(inputs, perm=[0, 2, 1, 3])\n",
"\n",
" def call(self, inputs):\n",
+ " '''\n",
+ " 1. query, key, value를 각각 Dense 레이어를 통과시켜서 출력값을 얻습니다.\n",
+ " 2. 각 head로 나눠진 query, key, value를 scaled_dot_product_attention() 함수에 입력값으로 넣어 어텐션을 수행합니다.\n",
+ " 3. 어텐션의 결과를 다시 transpose() 함수를 이용해 축을 변환합니다.\n",
+ " 4. 각 head를 다시 연결(concatenate)하여 최종 결과를 얻습니다.\n",
+ " 5. 결과값을 dense 레이어를 통과시켜 최종 출력값을 구합니다.\n",
+ " \n",
+ " query, key, value가 multi-heads 수만큼 나뉘어서 어텐션을 계산\n",
+ " 각 head는 서로 다른 부분을 학습하기 위해서 존재하며, 이를 통해 모델이 더욱 효과적으로 특징을 추출함\n",
+ " 출력값으로는 각 단어의 위치와 상관없이 모든 단어가 attention을 받은 정보가 담긴 벡터를 반환함\n",
+ " '''\n",
" query, key, value, mask = inputs['query'], inputs['key'], inputs[\n",
" 'value'], inputs['mask']\n",
" batch_size = tf.shape(query)[0]\n",
@@ -344,7 +419,7 @@
},
{
"cell_type": "code",
- "execution_count": 9,
+ "execution_count": null,
"id": "3d76ee2e",
"metadata": {
"id": "3d76ee2e"
@@ -352,8 +427,11 @@
"outputs": [],
"source": [
"def create_padding_mask(x):\n",
+ "#입력으로 들어온 'x' tensor에서 값이 0인 위치에 1을, 그 외의 위치에 0을 가지는 텐서를 생성하는 함수\n",
" mask = tf.cast(tf.math.equal(x, 0), tf.float32)\n",
" # (batch_size, 1, 1, key의 문장 길이)\n",
+ " ## 입력으로 (batch_size, seq_len) 크기의 텐서 x가 주어졌다면, \n",
+ " ## 이 함수는 (batch_size, 1, 1, seq_len) 크기의 텐서를 반환\n",
" return mask[:, tf.newaxis, tf.newaxis, :]"
]
},
@@ -369,7 +447,7 @@
},
{
"cell_type": "code",
- "execution_count": 10,
+ "execution_count": null,
"id": "75149d08",
"metadata": {
"id": "75149d08"
@@ -377,6 +455,30 @@
"outputs": [],
"source": [
"def encoder_layer(dff, d_model, num_heads, dropout, name=\"encoder_layer\"):\n",
+ " '''\n",
+ " dff : feedforward network의 hidden layer에 있는 뉴런 수를 나타내는 정수\n",
+ " d_model : 모델의 차원을 나타내는 정수. 즉, 임베딩 크기\n",
+ " num_heads : attention head 개수를 나타내는 정수\n",
+ " dropout : 드롭아웃 비율을 나타내는 실수\n",
+ " name : 레이어 이름을 나타내는 문자열\n",
+ " '''\n",
+ "\n",
+ " '''\n",
+ " 간단히 말하자면\n",
+ " 1. 입력 데이터(inputs)와 패딩 마스크(padding_mask)를 받고\n",
+ " 2. 멀티 헤드 어텐션을 수행한 뒤\n",
+ " 3. 드롭아웃을 적용하고 잔차 연결(residual connection)과 \n",
+ " 층 정규화(layer normalization)를 수행함\n",
+ " 4. 포지션 와이즈 피드 포워드 신경망을 수행하는데, \n",
+ " 이때 입력으로 받은 어텐션 출력(attention)을 사용하고\n",
+ " 5. 드롭아웃을 적용하고 잔차 연결과 층 정규화를 수행함\n",
+ "\n",
+ " return에선 \n",
+ " - 입력 데이터(inputs)와 패딩 마스크(padding_mask)를 입력으로 받음\n",
+ " - 출력으로는 두번째 서브층의 입력으로 사용될 어텐션 출력(attention)에 \n",
+ " 두번째 서브층을 수행한 결과를 더한 결과\n",
+ " 를 반환하는 tf.keras.Model 객체를 생성\n",
+ " '''\n",
" inputs = tf.keras.Input(shape=(None, d_model), name=\"inputs\")\n",
"\n",
" # 인코더는 패딩 마스크 사용\n",
@@ -395,14 +497,19 @@
" epsilon=1e-6)(inputs + attention)\n",
"\n",
" # 포지션 와이즈 피드 포워드 신경망 (두번째 서브층)\n",
- " outputs = tf.keras.layers.Dense(units=dff, activation='relu')(attention)\n",
- " outputs = tf.keras.layers.Dense(units=d_model)(outputs)\n",
+ " outputs = tf.keras.layers.Dense(units=dff, activation='relu')(attention) #ReLU와\n",
+ " outputs = tf.keras.layers.Dense(units=d_model)(outputs) \n",
+ " #선형활성화 함수가 있는 두 개의 고밀도 레이어로 구성됨\n",
"\n",
" # 드롭아웃 + 잔차 연결과 층 정규화\n",
" outputs = tf.keras.layers.Dropout(rate=dropout)(outputs)\n",
" outputs = tf.keras.layers.LayerNormalization(\n",
- " epsilon=1e-6)(attention + outputs)\n",
+ " epsilon=1e-6)(attention + outputs) \n",
+ " #attention tensor에 드롭아웃 적용된 출력텐서를 더함\n",
+ " #그리고 레이어 정규화를 적용해 다른 잔차 연결을 얻음\n",
"\n",
+ " #최종 출력은 output tensor, 출력 텐서를 출력으로 하는 tf.keras.Model 객체를 반환\n",
+ " #모델 이름은 name\n",
" return tf.keras.Model(\n",
" inputs=[inputs, padding_mask], outputs=outputs, name=name)\n",
" "
@@ -410,7 +517,7 @@
},
{
"cell_type": "code",
- "execution_count": 11,
+ "execution_count": null,
"id": "edda14f2",
"metadata": {
"id": "edda14f2"
@@ -420,25 +527,33 @@
"def encoder(vocab_size, num_layers, dff,\n",
" d_model, num_heads, dropout,\n",
" name=\"encoder\"):\n",
+ " '''\n",
+ " 다수의 self attention과 feedfoward 신경망으로 구성된 인코더를 구현하는 함수\n",
+ " '''\n",
" inputs = tf.keras.Input(shape=(None,), name=\"inputs\")\n",
"\n",
" # 인코더는 패딩 마스크 사용\n",
" padding_mask = tf.keras.Input(shape=(1, 1, None), name=\"padding_mask\")\n",
- "\n",
+ " #입력문장을 받아들이고 입력 문장에 대한 패딩마스크를 입력으로 받음\n",
+ " #그리고 입력 문장의 임베딩을 구성한 뒤, positional encoding을 적용함 \n",
" # 포지셔널 인코딩 + 드롭아웃\n",
" embeddings = tf.keras.layers.Embedding(vocab_size, d_model)(inputs)\n",
" embeddings *= tf.math.sqrt(tf.cast(d_model, tf.float32))\n",
+ " #이때 임베딩 차원 수와 포지셔널 인코딩 차원 수가 같도록 조정해줌\n",
" embeddings = PositionalEncoding(vocab_size, d_model)(embeddings)\n",
+ " #마지막으로 드롭아웃을 적용함.\n",
" outputs = tf.keras.layers.Dropout(rate=dropout)(embeddings)\n",
"\n",
- " # 인코더를 num_layers개 쌓기\n",
+ " # 인코더 층을 num_layers개 쌓기\n",
" for i in range(num_layers):\n",
" outputs = encoder_layer(dff=dff, d_model=d_model, num_heads=num_heads,\n",
" dropout=dropout, name=\"encoder_layer_{}\".format(i),\n",
" )([outputs, padding_mask])\n",
+ " #encoder_layer 함수를 for문 만큼 사용\n",
"\n",
" return tf.keras.Model(\n",
- " inputs=[inputs, padding_mask], outputs=outputs, name=name)"
+ " inputs=[inputs, padding_mask], outputs=outputs, name=name)\n",
+ " #tf.keras.Model 객체를 반환하는데, 반환되는 모델명은 name으로 지정됨."
]
},
{
@@ -453,7 +568,7 @@
},
{
"cell_type": "code",
- "execution_count": 12,
+ "execution_count": null,
"id": "fed9cc2c",
"metadata": {
"id": "fed9cc2c"
@@ -462,15 +577,33 @@
"source": [
"# 디코더의 첫번째 서브층(sublayer)에서 미래 토큰을 Mask하는 함수\n",
"def create_look_ahead_mask(x):\n",
+ " '''\n",
+ " 디코더는 현재 위치의 이전 토큰들을 이용해 다음 토큰을 예측하므로, \n",
+ " 현재 위치 이후에 등장하는 토큰들은 모두 가려주어야 함\n",
+ " '''\n",
" seq_len = tf.shape(x)[1]\n",
+ " #x 텐서의 shape을 이용해 seq_len을 구함\n",
" look_ahead_mask = 1 - tf.linalg.band_part(tf.ones((seq_len, seq_len)), -1, 0)\n",
+ " #tf.linalg.band_part() : seq_len 크기의 전체 1ㄹ로 구성된 정방행렬 만듦\n",
" padding_mask = create_padding_mask(x) # 패딩 마스크도 포함\n",
- " return tf.maximum(look_ahead_mask, padding_mask)"
+ " return tf.maximum(look_ahead_mask, padding_mask)\n",
+ "'''tf.maximum() 함수: element-wise maximum(각 element 별로 큰 값을 선택하는 함수)\n",
+ "이전에 만든 패딩 마스크와 조합해 현재 위치의 이후 위치들을 모두 가려주는 마스크를 만들고 반환함.\n",
+ "\n",
+ "tf.maximum(look_ahead_mask, padding_mask): element-wise maximum(각 element 별로 큰 값을 선택하는 함수)\n",
+ "\n",
+ "- look_ahead_mask : 미래 토큰을 Masking 하는데 사용되는 마스크\n",
+ "- padding_mask : 패딩 토큰을 Masking 하는데 사용되는 마스크\n",
+ "\n",
+ "두 마스크를 maximum 함수에 적용해서 \n",
+ "\"각 위치에서 패딩토큰과 미래토큰 중 하나가 존재하는 경우에는 해당 위치를 마스킹하도록 결정\"\n",
+ "-> 이렇게 결합된 마스크는 패딩 및 미래 토큰 모두를 마스킹하는 마스크를 생성함.\n",
+ "'''"
]
},
{
"cell_type": "code",
- "execution_count": 13,
+ "execution_count": null,
"id": "e9ba8f4b",
"metadata": {
"id": "e9ba8f4b"
@@ -478,19 +611,28 @@
"outputs": [],
"source": [
"def decoder_layer(dff, d_model, num_heads, dropout, name=\"decoder_layer\"):\n",
+ " #디코더의 sublayer를 구성하는 함수\n",
" inputs = tf.keras.Input(shape=(None, d_model), name=\"inputs\")\n",
" enc_outputs = tf.keras.Input(shape=(None, d_model), name=\"encoder_outputs\")\n",
"\n",
" # 디코더는 룩어헤드 마스크(첫번째 서브층)와 패딩 마스크(두번째 서브층) 둘 다 사용.\n",
" look_ahead_mask = tf.keras.Input(\n",
- " shape=(1, None, None), name=\"look_ahead_mask\")\n",
+ " shape=(1, None, None), name=\"look_ahead_mask\") #미래토큰을 masking 하도록 사용\n",
" padding_mask = tf.keras.Input(shape=(1, 1, None), name='padding_mask')\n",
+ " # 패딩된 부분을 masking하도록 padding_mask를 사용함.\n",
+ "\n",
+ " \n",
"\n",
" # 멀티-헤드 어텐션 (첫번째 서브층 / 마스크드 셀프 어텐션)\n",
" attention1 = MultiHeadAttention(\n",
" d_model, num_heads, name=\"attention_1\")(inputs={\n",
" 'query': inputs, 'key': inputs, 'value': inputs, # Q = K = V\n",
" 'mask': look_ahead_mask # 룩어헤드 마스크\n",
+ " #look_ahed_mask랑 padding mask 모두 사용하려면\n",
+ " #look_ahed_mask 함수 내 tf.maximum 함수를 사용해 둘 중 더 큰 값을 선택함.\n",
+ " \n",
+ " #그러면 디코더의 첫번째 sublayer에선 미래 정보를 참조 못하고, \n",
+ " #두번째 sublayer에선 패딩된 부분을 참조하지 못하게 함.\n",
" })\n",
"\n",
" # 잔차 연결과 층 정규화\n",
@@ -526,7 +668,7 @@
},
{
"cell_type": "code",
- "execution_count": 14,
+ "execution_count": null,
"id": "66f05031",
"metadata": {
"id": "66f05031"
@@ -575,7 +717,7 @@
},
{
"cell_type": "code",
- "execution_count": 15,
+ "execution_count": null,
"id": "dcc9c225",
"metadata": {
"id": "dcc9c225"
@@ -625,7 +767,7 @@
},
{
"cell_type": "code",
- "execution_count": 16,
+ "execution_count": null,
"id": "157eba42",
"metadata": {
"colab": {
@@ -677,12 +819,14 @@
"id": "6f6a3a83"
},
"source": [
- "## 손실함수"
+ "## 손실함수\n",
+ "- seq2seq에서 사용되는 손실함수\n",
+ "- 인코더에서 출력된 context vector를 decoder에 입력하고, 디코더에서 이를 기반으로 출력된 문장을 실제 정답 문장과 비교해서 손실을 계산함."
]
},
{
"cell_type": "code",
- "execution_count": 17,
+ "execution_count": null,
"id": "87a3d5ec",
"metadata": {
"id": "87a3d5ec"
@@ -690,14 +834,25 @@
"outputs": [],
"source": [
"def loss_function(y_true, y_pred):\n",
- " y_true = tf.reshape(y_true, shape=(-1, MAX_LENGTH - 1))\n",
- "\n",
+ " #y_true : 실제 정답 문장\n",
+ " #y_pred : 디코더에서 출력된 모델의 예측값\n",
+ " y_true = tf.reshape(y_true, shape=(-1, MAX_LENGTH - 1)) \n",
+ " '''\n",
+ " MAX_LENGTH -1의 형태로 reshape하는 이유는 \n",
+ " 디코더에서 사용되는 'start token'을 제외한 모든 토큰을 포함하기 위함.\n",
+ " '''\n",
" loss = tf.keras.losses.SparseCategoricalCrossentropy(\n",
" from_logits=True, reduction='none')(y_true, y_pred)\n",
+ " #SparseCategoricalCrossentropy : y_true와 y_pred 간의 손실 계산\n",
+ " #from_logits=True : y_pred가 확률이 아니라 logit값이므로 softmax함수를 거치지 않게끔 함.\n",
+ " #reduction=none : 배치 단위의 데이터의 평균 대신 각각의 샘플에 대한 손실값을 반환함.\n",
"\n",
" mask = tf.cast(tf.not_equal(y_true, 0), tf.float32)\n",
+ " #y_true가 패딩 토큰인 경우에 대한 손실을 제외하고자 마스크를 적용\n",
+ " #패딩토큰에 해당하는 부분은 mask 변수를 사용해 0으로 설정함.\n",
" loss = tf.multiply(loss, mask)\n",
- "\n",
+ " #손실값과 마스크를 곱해 마스크가 적용된 손실을 계산하고, \n",
+ " #이를 평균 내어 반환함.\n",
" return tf.reduce_mean(loss)"
]
},
@@ -708,12 +863,15 @@
"id": "8a831e8a"
},
"source": [
- "## custom schedule"
+ "## custom schedule\n",
+ "- tf.keras.optimizers.schedules.LearningRateSchedule를 상속\n",
+ "- 낮은 학습률로 시작하여 점차적으로 학습률을 높여 다시 감소하기 시작하는 지점까지 학습률을 높이도록 설계됨\n",
+ " - 신경망 훈련에서 일반적으로 사용되는 방식"
]
},
{
"cell_type": "code",
- "execution_count": 18,
+ "execution_count": null,
"id": "2f74e232",
"metadata": {
"id": "2f74e232"
@@ -723,21 +881,33 @@
"class CustomSchedule(tf.keras.optimizers.schedules.LearningRateSchedule):\n",
"\n",
" def __init__(self, d_model, warmup_steps=4000):\n",
+ " '''모델의 차원 크기(`d_model`)와 워밍업 단계 수(`warmup_steps`)를 포함하여 \n",
+ " 스케줄의 하이퍼파라미터를 초기화함\n",
+ " '''\n",
" super(CustomSchedule, self).__init__()\n",
" self.d_model = d_model\n",
" self.d_model = tf.cast(self.d_model, tf.float32)\n",
" self.warmup_steps = warmup_steps\n",
+ " \n",
"\n",
" def __call__(self, step):\n",
+ " '''d_model` 매개 변수는 `__call__` 메서드 내부의 나누기 연산이 \n",
+ " 정수를 반환하도록 하기 위해 정수로 캐스팅됨.\n",
+ " '''\n",
+ " #현재 훈련 단계를 나타내는 `step` 매개 변수를 받음\n",
+ " #이 메서드는 현재 단계에서 학습률을 계산하는 데 사용되는 두 개의 인수인 `arg1`과 `arg2`를 계산\n",
" arg1 = tf.math.rsqrt(step)\n",
+ " #'arg1'은 스텝 수의 역제곱근으로 계산\n",
" arg2 = step * (self.warmup_steps**-1.5)\n",
- "\n",
- " return tf.math.rsqrt(self.d_model) * tf.math.minimum(arg1, arg2)"
+ " #'arg2'는 스텝 수에 'warmup_steps'의 역제곱근을 `-1.5`의 거듭제곱으로 곱한 값으로 계산\n",
+ " \n",
+ " return tf.math.rsqrt(self.d_model) * tf.math.minimum(arg1, arg2)\n",
+ " #학습률은 `d_model`의 역제곱근에 `arg1`과 `arg2`의 최소값을 곱한 값으로 계산"
]
},
{
"cell_type": "code",
- "execution_count": 19,
+ "execution_count": null,
"id": "4fb94965",
"metadata": {
"colab": {
@@ -771,927 +941,13 @@
],
"source": [
"sample_learning_rate = CustomSchedule(d_model=128)\n",
+ "#각 단어를 모델에서 128차원의 벡터로 표현하도록 함\n",
"\n",
"plt.plot(sample_learning_rate(tf.range(200000, dtype=tf.float32)))\n",
+ "#training step이 200000번임.\n",
"plt.ylabel(\"Learning Rate\")\n",
"plt.xlabel(\"Train Step\")"
]
- },
- {
- "cell_type": "markdown",
- "id": "926cf6fb",
- "metadata": {
- "id": "926cf6fb"
- },
- "source": [
- "## 챗봇 구현(에러 발생...)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 20,
- "id": "679eb7b4",
- "metadata": {
- "id": "679eb7b4"
- },
- "outputs": [],
- "source": [
- "import pandas as pd\n",
- "import urllib.request\n",
- "import tensorflow_datasets as tfds\n",
- "import tensorflow as tf\n",
- "import time\n",
- "import numpy as np\n",
- "import matplotlib.pyplot as plt\n",
- "import re"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 21,
- "id": "0812f07a",
- "metadata": {
- "colab": {
- "base_uri": "https://localhost:8080/",
- "height": 206
- },
- "id": "0812f07a",
- "outputId": "d36dd8e2-823e-4774-993f-08447534bc7c"
- },
- "outputs": [
- {
- "output_type": "execute_result",
- "data": {
- "text/plain": [
- " Q A label\n",
- "0 12시 땡! 하루가 또 가네요. 0\n",
- "1 1지망 학교 떨어졌어 위로해 드립니다. 0\n",
- "2 3박4일 놀러가고 싶다 여행은 언제나 좋죠. 0\n",
- "3 3박4일 정도 놀러가고 싶다 여행은 언제나 좋죠. 0\n",
- "4 PPL 심하네 눈살이 찌푸려지죠. 0"
- ],
- "text/html": [
- "\n",
- " | \n", - " | Q | \n", - "A | \n", - "label | \n", - "
|---|---|---|---|
| 0 | \n", - "12시 땡! | \n", - "하루가 또 가네요. | \n", - "0 | \n", - "
| 1 | \n", - "1지망 학교 떨어졌어 | \n", - "위로해 드립니다. | \n", - "0 | \n", - "
| 2 | \n", - "3박4일 놀러가고 싶다 | \n", - "여행은 언제나 좋죠. | \n", - "0 | \n", - "
| 3 | \n", - "3박4일 정도 놀러가고 싶다 | \n", - "여행은 언제나 좋죠. | \n", - "0 | \n", - "
| 4 | \n", - "PPL 심하네 | \n", - "눈살이 찌푸려지죠. | \n", - "0 | \n", - "
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## Transformer를 사용하는 데 쓰이는 라이브러리\n",
+ "- transformer에 기반하는 다른 모델을 사용할 수 있는 라이브러리가 많았고, transformer 기능을 구현하는 코드를 통해서 짚어보기로 함.\n",
+ "- tensorflow(아래 구현 코드에서 확인 가능)\n",
+ "- pytorch\n",
+ " - https://pytorch.kr/hub/huggingface_pytorch-transformers/\n",
+ "- huggingface transformers\n",
+ " - https://github.com/huggingface/transformers/blob/main/README_ko.md\n",
+ "- fairseq\n",
+ " - https://cloud.google.com/tpu/docs/tutorials/transformer-pytorch?hl=ko"
+ ],
+ "metadata": {
+ "id": "DXRgJAGiD0-Z"
+ },
+ "id": "DXRgJAGiD0-Z"
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2fe11c0f",
+ "metadata": {
+ "id": "2fe11c0f"
+ },
+ "source": [
+ "## 필요 라이브러리 import"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "bbebe731",
+ "metadata": {
+ "id": "bbebe731"
+ },
+ "outputs": [],
+ "source": [
+ "import numpy as np\n",
+ "import matplotlib.pyplot as plt\n",
+ "import tensorflow as tf"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5cd2132b",
+ "metadata": {
+ "id": "5cd2132b"
+ },
+ "source": [
+ "TypeError: Unable to convert function return value to a Python type! The signature was\n",
+ "\t() -> handle\n",
+ "- tensorflow를 import 할 때, 해당 오류가 발생하는 건 tensorflow 라이브러리 버전이 낮기 때문임.\n",
+ " - pip install --upgrade tensorflow\n",
+ " - pip uninstall tensorflow 하고서 pip install tensorflow 하기"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b9c7b06c",
+ "metadata": {
+ "id": "b9c7b06c"
+ },
+ "source": [
+ "ERROR: Could not install packages due to an OSError: [WinError 5] 액세스가 거부되었습니다: \n",
+ "- 해당 에러가 cmd 창에서 나타나는 경우, 다음 명령문을 conda install 전에 입력한다.\n",
+ " - conda config --set ssl_verify false\n",
+ " - conda install pip tensorflow"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "위의 방식대로 했는데도 안 됐음...\n",
+ "--> 근데 그냥... 코랩으로 돌리면 되는 거였음..."
+ ],
+ "metadata": {
+ "id": "mSVrStdeJrjB"
+ },
+ "id": "mSVrStdeJrjB"
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "92cc660a",
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 35
+ },
+ "id": "92cc660a",
+ "outputId": "d0cb368f-7bd3-4880-beac-acfea6e2db1e"
+ },
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "'2.12.0'"
+ ],
+ "application/vnd.google.colaboratory.intrinsic+json": {
+ "type": "string"
+ }
+ },
+ "metadata": {},
+ "execution_count": 4
+ }
+ ],
+ "source": [
+ "tf.__version__ #2.6.0 이상 버전에서 작업 진행 필요"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6f9aa344",
+ "metadata": {
+ "id": "6f9aa344"
+ },
+ "source": [
+ "## Positional Encoding 구현"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Tensorflow 및 Keras에서 Positional Encoding 레이어를 정의하는 내용.\n",
+ "- transformer의 입력 시퀀스에 위치 인코딩을 추가해주는 역할\n",
+ " - 위치 인코딩 : 입력 시퀀스의 토큰 위치에 대한 정보를 모델에 제공하기 위해 사용되며, 이는 시퀀스의 순서와 문맥을 이해하는 데 중요함."
+ ],
+ "metadata": {
+ "id": "5mPnbVw6T50X"
+ },
+ "id": "5mPnbVw6T50X"
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "d833813b",
+ "metadata": {
+ "id": "d833813b"
+ },
+ "outputs": [],
+ "source": [
+ "class PositionalEncoding(tf.keras.layers.Layer): #tf.keras.layers.Layer를 상속받음\n",
+ " def __init__(self, position, d_model): \n",
+ " #position:입력시퀀스의 최대길이, d_model:입력 임베딩의 차원\n",
+ " super(PositionalEncoding, self).__init__()\n",
+ " self.pos_encoding = self.positional_encoding(position, d_model)\n",
+ "\n",
+ " def get_angles(self, position, i, d_model):\n",
+ " #모든 위치, 임베딩 차원에 대한 각도 배열 반환.\n",
+ " # i : 각도의 인덱스\n",
+ " ## 짝수면 2로 나뉘어져서 지수가 0 -> sin함수 쓸 때 사용되는 각도 생성\n",
+ " ## 홀수면 지수가 1 -> cos함수 쓸 때 사용되는 각도 생성\n",
+ " angles = 1 / tf.pow(10000, (2 * (i // 2)) / tf.cast(d_model, tf.float32))\n",
+ " return position * angles\n",
+ " # tf.pow : x^y\n",
+ " # tf.cast:배열의 데이터타입을 바꿔줌. 여기선 d_model을 float32형태로 변화.\n",
+ "\n",
+ " def positional_encoding(self, position, d_model):\n",
+ " \n",
+ " #get_angles 함수 : 인코딩할 단어 위치(position), 임베딩 차원(d_model),\n",
+ " #인덱스(i)에 따라 각도(angles) 계산함\n",
+ " angle_rads = self.get_angles(\n",
+ " position=tf.range(position, dtype=tf.float32)[:, tf.newaxis],\n",
+ " i=tf.range(d_model, dtype=tf.float32)[tf.newaxis, :],\n",
+ " d_model=d_model) \n",
+ "\n",
+ " # 배열의 짝수 인덱스(2i)에는 사인 함수 적용\n",
+ " sines = tf.math.sin(angle_rads[:, 0::2])\n",
+ "\n",
+ " # 배열의 홀수 인덱스(2i+1)에는 코사인 함수 적용\n",
+ " cosines = tf.math.cos(angle_rads[:, 1::2])\n",
+ "\n",
+ " angle_rads = np.zeros(angle_rads.shape) \n",
+ " #계산된 sines와 cosines를 이용해 각도 배열(angle_rads) 만듦\n",
+ " angle_rads[:, 0::2] = sines\n",
+ " angle_rads[:, 1::2] = cosines\n",
+ " pos_encoding = tf.constant(angle_rads)\n",
+ " #angle_rads 기반으로 pos_encoding 배열을 만듦\n",
+ " #이 배열은 angle_rads를 그대로 복사한 다음에, tf.newaxis로 차원을 추가하고\n",
+ " pos_encoding = pos_encoding[tf.newaxis, ...]\n",
+ "\n",
+ " print(pos_encoding.shape)\n",
+ " #tf.cast를 이용해 float32형태로 변경함\n",
+ " return tf.cast(pos_encoding, tf.float32)\n",
+ " #해당 배열의 모양은 (1=배치차원, position, d_model)임.\n",
+ " \n",
+ " '''\n",
+ " 딥러닝 모델 학습 시, 데이터셋은 일반적으로 미니배치(minibatch) 단위로 처리됨\n",
+ " 전체 데이터셋이 아닌 일부 데이터(ex. 32개의 이미지)를 한번에 모델에 입력하고, 그 출력을 이용해 모델을 학습시킴\n",
+ " 이렇게 모델에 입력되는 데이터의 묶음을 미니 배치라고 하며, 미니배치 단위로 \n",
+ " 처리하는 건 GPU를 비롯한 하드웨어의 병렬 처리 기능을 활용해 연산 속도를 높일 수 있음.\n",
+ "\n",
+ " 배치 차원 = 미니 배치의 크기\n",
+ " 배열은 1개의 미니배치를 처리함.\n",
+ " '''\n",
+ "\n",
+ " def call(self, inputs): \n",
+ " #input sequence에 tensor 추가되고, \n",
+ " #브로드캐스팅을 사용해 위치 인코딩이 시퀀스의 올바른 부분에 추가되도록 보장함.\n",
+ " ## 브로드캐스팅 : NumPy 및 TensorFlow와 같은 배열/텐서 연산에서 자동으로 배열/텐서의 크기를 조정해 연산이 가능하도록 하는 기능\n",
+ " return inputs + self.pos_encoding[:, :tf.shape(inputs)[1], :]\n",
+ " ##self는 pos_encoding의 첫번째 차원인 배치 차원과 동일함."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "026d42a0",
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 473
+ },
+ "id": "026d42a0",
+ "outputId": "650011ba-be03-4c83-d2fb-7135aea515d1"
+ },
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "(1, 50, 128)\n"
+ ]
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "# Details\n",
+ "Training : 빠른 학습속도를 위한 AMP 사용\n",
+ "Epoch : 10\n",
+ "Data : 각 모델별로 5 Fold 학습\n",
+ "Model : 'monologg/kobert', 'klue/roberta-base', 'klue/roberta-small', 'klue/roberta-large', 'xlm-roberta-large', 'bert-base-multilingual-uncased'\n",
+ "Ensemble : logit ensemble"
+ ],
+ "metadata": {
+ "id": "mpZY6sFLDjmm"
+ },
+ "id": "mpZY6sFLDjmm"
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0343a98b",
+ "metadata": {
+ "id": "0343a98b"
+ },
+ "source": [
+ "## 시작"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "!pip install torch_optimizer\n",
+ "#torch_optimizer는 PyTorch를 기반으로 하는 \"딥러닝 모델의 최적화\"를 위한 여러 알고리즘을 제공하는 라이브러리"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "L0hQWVizkqoO",
+ "outputId": "4ec43b95-037a-4e32-f646-a00538c5bd51"
+ },
+ "id": "L0hQWVizkqoO",
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
+ "Collecting torch_optimizer\n",
+ " Downloading torch_optimizer-0.3.0-py3-none-any.whl (61 kB)\n",
+ "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m61.9/61.9 KB\u001b[0m \u001b[31m1.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+ "\u001b[?25hCollecting pytorch-ranger>=0.1.1\n",
+ " Downloading pytorch_ranger-0.1.1-py3-none-any.whl (14 kB)\n",
+ "Requirement already satisfied: torch>=1.5.0 in /usr/local/lib/python3.9/dist-packages (from torch_optimizer) (2.0.0+cu118)\n",
+ "Requirement already satisfied: filelock in /usr/local/lib/python3.9/dist-packages (from torch>=1.5.0->torch_optimizer) (3.10.7)\n",
+ "Requirement already satisfied: jinja2 in /usr/local/lib/python3.9/dist-packages (from torch>=1.5.0->torch_optimizer) (3.1.2)\n",
+ "Requirement already satisfied: triton==2.0.0 in /usr/local/lib/python3.9/dist-packages (from torch>=1.5.0->torch_optimizer) (2.0.0)\n",
+ "Requirement already satisfied: networkx in /usr/local/lib/python3.9/dist-packages (from torch>=1.5.0->torch_optimizer) (3.0)\n",
+ "Requirement already satisfied: sympy in /usr/local/lib/python3.9/dist-packages (from torch>=1.5.0->torch_optimizer) (1.11.1)\n",
+ "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.9/dist-packages (from torch>=1.5.0->torch_optimizer) (4.5.0)\n",
+ "Requirement already satisfied: lit in /usr/local/lib/python3.9/dist-packages (from triton==2.0.0->torch>=1.5.0->torch_optimizer) (16.0.0)\n",
+ "Requirement already satisfied: cmake in /usr/local/lib/python3.9/dist-packages (from triton==2.0.0->torch>=1.5.0->torch_optimizer) (3.25.2)\n",
+ "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.9/dist-packages (from jinja2->torch>=1.5.0->torch_optimizer) (2.1.2)\n",
+ "Requirement already satisfied: mpmath>=0.19 in /usr/local/lib/python3.9/dist-packages (from sympy->torch>=1.5.0->torch_optimizer) (1.3.0)\n",
+ "Installing collected packages: pytorch-ranger, torch_optimizer\n",
+ "Successfully installed pytorch-ranger-0.1.1 torch_optimizer-0.3.0\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "!pip install transformers\n",
+ "#transformers : 딥러닝 자연어 처리 모델 구현 라이브러리\n",
+ "##다양한 pre-trained 언어 모델을 제공하고, 이를 fine-tunning 해서 특정 자연어 처리 task에 맞는 모델을 만들 수 있음"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "O-hRaYsBkwrr",
+ "outputId": "1290dce9-58c6-47c3-cb9b-ff87c55ab41a"
+ },
+ "id": "O-hRaYsBkwrr",
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
+ "Collecting transformers\n",
+ " Downloading transformers-4.27.4-py3-none-any.whl (6.8 MB)\n",
+ "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m6.8/6.8 MB\u001b[0m \u001b[31m46.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+ "\u001b[?25hRequirement already satisfied: tqdm>=4.27 in /usr/local/lib/python3.9/dist-packages (from transformers) (4.65.0)\n",
+ "Requirement already satisfied: regex!=2019.12.17 in /usr/local/lib/python3.9/dist-packages (from transformers) (2022.10.31)\n",
+ "Requirement already satisfied: pyyaml>=5.1 in /usr/local/lib/python3.9/dist-packages (from transformers) (6.0)\n",
+ "Requirement already satisfied: numpy>=1.17 in /usr/local/lib/python3.9/dist-packages (from transformers) (1.22.4)\n",
+ "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.9/dist-packages (from transformers) (23.0)\n",
+ "Requirement already satisfied: requests in /usr/local/lib/python3.9/dist-packages (from transformers) (2.27.1)\n",
+ "Requirement already satisfied: filelock in /usr/local/lib/python3.9/dist-packages (from transformers) (3.10.7)\n",
+ "Collecting huggingface-hub<1.0,>=0.11.0\n",
+ " Downloading huggingface_hub-0.13.4-py3-none-any.whl (200 kB)\n",
+ "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m200.1/200.1 KB\u001b[0m \u001b[31m12.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+ "\u001b[?25hCollecting tokenizers!=0.11.3,<0.14,>=0.11.1\n",
+ " Downloading tokenizers-0.13.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (7.8 MB)\n",
+ "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m7.8/7.8 MB\u001b[0m \u001b[31m64.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+ "\u001b[?25hRequirement already satisfied: typing-extensions>=3.7.4.3 in /usr/local/lib/python3.9/dist-packages (from huggingface-hub<1.0,>=0.11.0->transformers) (4.5.0)\n",
+ "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.9/dist-packages (from requests->transformers) (2022.12.7)\n",
+ "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /usr/local/lib/python3.9/dist-packages (from requests->transformers) (1.26.15)\n",
+ "Requirement already satisfied: charset-normalizer~=2.0.0 in /usr/local/lib/python3.9/dist-packages (from requests->transformers) (2.0.12)\n",
+ "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.9/dist-packages (from requests->transformers) (3.4)\n",
+ "Installing collected packages: tokenizers, huggingface-hub, transformers\n",
+ "Successfully installed huggingface-hub-0.13.4 tokenizers-0.13.3 transformers-4.27.4\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "- pre-trained\n",
+ " - pre-trained model : 대규모 데이터 셋에서 미리 학습된 모델 -> 다른 자연어 처리 task에서도 유용(BERT가 Wikipedia 대규모 데이터셋에서 사전학습되었고, 다양한 자연어 처리 업무에 사용 가능)\n",
+ " - 학습시간을 줄이고 소규모 데이터셋에서도 높은 성능 획득 가능\n",
+ "- fine-tunning\n",
+ " - pre-trained 모델을 사용해 특정 자연어 처리 업무에 맞는 모델을 만드는 과정\n",
+ " - 단계\n",
+ " > pre-trained model을 특정 자연어 처리 태스크에 맞게 fine-tunning\n",
+ " > --> 이 fine-tuned 모델은 특정 태스크에 대해 더 좋은 성능 발휘"
+ ],
+ "metadata": {
+ "id": "PhkA0kWajgNQ"
+ },
+ "id": "PhkA0kWajgNQ"
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "9892bce4",
+ "metadata": {
+ "code_folding": [
+ 0
+ ],
+ "id": "9892bce4"
+ },
+ "outputs": [],
+ "source": [
+ "# ------ LIBRARY -------#\n",
+ "import numpy as np\n",
+ "import os\n",
+ "import pickle\n",
+ "import sys\n",
+ "import pandas as pd\n",
+ "import re\n",
+ "import cv2\n",
+ "\n",
+ "# PyTorch 관련 라이브러리\n",
+ "import torch\n",
+ "import torch.cuda.amp as amp #Automatic Mixed Precision, GPU 메모리 사용량을 줄이고 학습 속도를 높이고자 사용하는 기술\n",
+ "\n",
+ "#데이터 로딩을 위한 라이브러리 : torch.utils.data, torch.utils.data.sampler\n",
+ "from torch.utils.data.dataset import Dataset\n",
+ "from torch.utils.data import DataLoader\n",
+ "from torch.utils.data.sampler import *\n",
+ "\n",
+ "#모델 학습 및 최적화를 위한 라이브러리 : torch.nn, torch.optim, torch.optim.lr_scheduler\n",
+ "import torch.nn as nn\n",
+ "import torch.nn.functional as F\n",
+ "from torch.optim.lr_scheduler import CosineAnnealingWarmRestarts, CosineAnnealingLR, ReduceLROnPlateau, MultiStepLR, OneCycleLR\n",
+ "\n",
+ "import math\n",
+ "\n",
+ "#optimizer는 학습 중 모델의 가중치를 업데이트하는 알고리즘\n",
+ "#required는 optimizer 클래스의 메소드에서 필수적으로 사용되는 인자를 표시하는 데 사용됨.\n",
+ "from torch.optim.optimizer import Optimizer, required\n",
+ "import torch_optimizer as optim\n",
+ "#defaultdict는 일반적인 dict와 유사하지만 존재하지 않는 키를 새로 만들 때 디폴트값을 반환함.\n",
+ "from collections import defaultdict\n",
+ "#itertools는 반복 가능한 객체를 다루는 유용한 함수들을 제공함\n",
+ "import itertools as it\n",
+ "\n",
+ "import tqdm #진행상황을 시각화하는 라이브러리(진행 바 같은 걸 출력해줌)\n",
+ "import random\n",
+ "#import time\n",
+ "import matplotlib.pyplot as plt\n",
+ "from timeit import default_timer as timer\n",
+ "from sklearn.model_selection import KFold\n",
+ "from sklearn.metrics import f1_score\n",
+ "from sklearn.preprocessing import LabelEncoder\n",
+ "from sklearn.preprocessing import StandardScaler\n",
+ "from sklearn.metrics import accuracy_score\n",
+ "\n",
+ "\n",
+ "# transformer 모델들과 tokenizer import\n",
+ "# trainsformer 모델들 : pretrained\n",
+ "from transformers import XLMPreTrainedModel, XLMRobertaModel, XLMRobertaConfig, XLMRobertaTokenizer\n",
+ "from transformers import XLMRobertaForSequenceClassification, BertForSequenceClassification\n",
+ "from transformers import AutoTokenizer\n",
+ "from transformers import BertForSequenceClassification, DistilBertForSequenceClassification, XLNetForSequenceClassification,\\\n",
+ "XLMRobertaForSequenceClassification, XLMForSequenceClassification, RobertaForSequenceClassification\n",
+ "#AdamW 최적화 알고리즘을 사용\n",
+ "from transformers import AdamW\n",
+ "#학습률 조절에 사용하는 함수\n",
+ "from transformers import get_linear_schedule_with_warmup"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f87869f9",
+ "metadata": {
+ "code_folding": [],
+ "id": "f87869f9"
+ },
+ "outputs": [],
+ "source": [
+ "# class args\n",
+ "class args: #여러 학습 인자의 값을 설정\n",
+ " # ---- factor ---- #\n",
+ " debug=False #디버그 모드 여부\n",
+ " amp = True #mixed precision을 사용할 지 여부\n",
+ " gpu = '0' #GPU 번호\n",
+ "\n",
+ " epochs=10 #에포크 수\n",
+ " batch_size=1 #배치 크기\n",
+ " weight_decay=1e-6 #가중치 감소 값\n",
+ " n_fold=5 #교차 검증(fold) 수\n",
+ " fold=3 # [0, 1, 2, 3, 4] # 원래는 3\n",
+ "\n",
+ " exp_name = 'experiment_name_folder'\n",
+ " dir_ = f'./saved_models/'\n",
+ " pt = 'your_model_name'\n",
+ " max_len = 33 #모델 입력 시퀀스의 최대 길이 설정\n",
+ " #학습률을 설정하는 파라미터\n",
+ " start_lr = 1e-5#1e-3,5e-5 #학습시 초기학습률 값을 의미. 학습 초기에 빠르게 수렴할 가능성이 있지만, 값이 너무 크면 수렴이 불안정해짐\n",
+ " min_lr=1e-6 #학습 중 학습율이 더이상 작아지지 않게 제한하는 값. 해당 값 이하로 떨어지지 않게 보장함.\n",
+ " # ---- Dataset ---- #\n",
+ "\n",
+ " # ---- Else ---- #\n",
+ " num_workers=8\n",
+ " seed=2021\n",
+ " scheduler = None#모델의 학습률을 조정하는 방법을 지정. 방법은 사용하지 않겠지만, 다른 변수를 이용해 학습률 조정 방식을 선택할 수 있음.\n",
+ "\n",
+ "\n",
+ "data_dir = './' # 데이터가 저장된 디렉토리 경로를 나타냄\n",
+ "os.environ[\"CUDA_VISIBLE_DEVICES\"] = args.gpu #args.gpu : 코드 실행 시 지정된 GPU의 인덱스\n",
+ "device = torch.device(f\"cuda\" if torch.cuda.is_available() else \"cpu\") #디바이스 유형 설정.\n",
+ "#만약 CUDA 디바이스가 사용 가능하면 \"cuda\"로 설정하고, 그렇지 않으면 \"cpu\"로 설정함. 이를 통해 디바이스 유형에 맞게 모델을 초기화할 수 있음.\n",
+ "\n",
+ "##모델 학습 시 랜덤 시드를 설정해 재현성을 보장\n",
+ "def set_seeds(seed=42):\n",
+ " random.seed(seed)\n",
+ " os.environ['PYTHONHASHSEED'] = str(seed)\n",
+ " np.random.seed(seed)\n",
+ " torch.manual_seed(seed)\n",
+ " torch.cuda.manual_seed(seed)\n",
+ " torch.cuda.manual_seed_all(seed)\n",
+ " #torch.backends.cudnn : NVIDIA cuDNN 라이브러리를 사용해서 PyTorch 연산의 실행 속도를 높이는 데 사용됨.\n",
+ " #cuDNN : Deep Neural Network 라이브러리, NVIDIA GPU에서 딥러닝 모델을 학습 및 추론할 때 연산속도를 높이기 위한 최적화된 기능을 제공\n",
+ " #torch.backends.cudnn을 쓰면 이런 최적화를 활용해 PyTorch 연산 속도를 높일 수 있음.\n",
+ " torch.backends.cudnn.deterministic = True #기본값이 True. 연산 실행 시간을 단축하고자 cuDNN 라이브러리가 실행 시간을 측정하고 최적화를 수행하는 걸 의미\n",
+ " torch.backends.cudnn.benchmark = False # 연산 결과가 항상 동일하지 않을 수 있다는 걸 의미함. -> 연산 속도 및 학습을 빠르게함\n",
+ "\n",
+ "set_seeds(seed=args.seed)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "299e9265",
+ "metadata": {
+ "code_folding": [
+ 1,
+ 11
+ ],
+ "id": "299e9265"
+ },
+ "outputs": [],
+ "source": [
+ "# - util - #\n",
+ "def get_learning_rate(optimizer): #현재 학습률을 가져와서 반환하는 함수\n",
+ " lr=[]\n",
+ " for param_group in optimizer.param_groups:\n",
+ " #param_groups : optimizer의 학습률과 weight decay 같은 하이퍼파라미터 관리\n",
+ " lr +=[ param_group['lr'] ]\n",
+ "\n",
+ " assert(len(lr)==1)\n",
+ " #'lr'의 길이가 1인지 확인하는데, 이건 현재 이 코드에서 하나의 학습률만 사용하기 때문임.\n",
+ " lr = lr[0]\n",
+ "\n",
+ " return lr\n",
+ "\n",
+ "def load_data(): #데이터 로드 합수\n",
+ " train=pd.read_csv('./train_data.csv')\n",
+ " test=pd.read_csv('./test_data.csv')\n",
+ "\n",
+ " #일부 column을 지정\n",
+ " train=train[['title','topic_idx']]\n",
+ " test=test[['title']]\n",
+ " #5-fold 교차 검증 수행\n",
+ " from sklearn.model_selection import StratifiedKFold\n",
+ " skf = StratifiedKFold(n_splits=5, random_state=42, shuffle=True)\n",
+ " train['fold'] = -1\n",
+ " for n_fold, (_,v_idx) in enumerate(skf.split(train, train['topic_idx'])):\n",
+ " train.loc[v_idx, 'fold'] = n_fold\n",
+ " #train 데이터에 fold와 id열을 추가\n",
+ " train['id'] = [x for x in range(len(train))]\n",
+ "\n",
+ " return train, test\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "86ed46c9",
+ "metadata": {
+ "heading_collapsed": true,
+ "id": "86ed46c9"
+ },
+ "source": [
+ "# 전처리"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "6feb9fe2",
+ "metadata": {
+ "code_folding": [
+ 0
+ ],
+ "hidden": true,
+ "id": "6feb9fe2"
+ },
+ "outputs": [],
+ "source": [
+ "# make KoBertTokenizer\n",
+ "# 한글을 토큰화할 수 있는 KoBert 모델용 custom tokenizer를 만드는 데 사용함.\n",
+ "import logging\n",
+ "import os\n",
+ "import unicodedata #유니코드 문자 처리를 위함\n",
+ "from shutil import copyfile #파일 복사\n",
+ "\n",
+ "from transformers import PreTrainedTokenizer\n",
+ "\n",
+ "logger = logging.getLogger(__name__)\n",
+ "#logger : 스크립트 실행되는 동안 메세지를 기록하는 데 사용함.\n",
+ "# 로거명을 __name__로 설정하면 현재 모듈명을 로거의 이름으로 사용함\n",
+ "# 이렇게 하면 각 모듈이 자체 로거를 가질 수 있으므로 대규모 애플리케이션에서 로그 메세지를 더 잘 구성할 수 있음.\n",
+ "\n",
+ "VOCAB_FILES_NAMES = {\"vocab_file\": \"tokenizer_78b3253a26.model\", # 어휘파일의 위치 지정\n",
+ " \"vocab_txt\": \"vocab.txt\"} # 어휘에 대한 토큰-index mapping 사전을 구축하는 데 쓰임.\n",
+ "#PRETRAINED_VOCAB_FILES_MAP 변수를 정의하는 코드\n",
+ "# hugging face의 transformer 라이브러리에서 사용되고, 사전 학습된 모델의 tokenizer와 관련된 파일들의 URL을 매핑함\n",
+ "#즉, 해당 모델에 대한 토크나이저와 어휘파일을 쉽게 다운로드할 수 있음.\n",
+ "PRETRAINED_VOCAB_FILES_MAP = {\n",
+ " #vocab_file과 vocab_txt는 각각 토크나이저 파이과 어휘 파일의 URL을 가리키는 사전임\n",
+ " \"vocab_file\": {\n",
+ " \"monologg/kobert\": \"https://s3.amazonaws.com/models.huggingface.co/bert/monologg/kobert/tokenizer_78b3253a26.model\",\n",
+ " #각각의 어휘파일의 링크가 제공됨.\n",
+ " #이 링크들은 Hugging Face에서 제공하는 S3 버킷에서 해당 어휘 파일을 다운로드할 수 있는 주소를 제공함.\n",
+ " \"monologg/kobert-lm\": \"https://s3.amazonaws.com/models.huggingface.co/bert/monologg/kobert-lm/tokenizer_78b3253a26.model\",\n",
+ " \"monologg/distilkobert\": \"https://s3.amazonaws.com/models.huggingface.co/bert/monologg/distilkobert/tokenizer_78b3253a26.model\"\n",
+ " #세 개의 다른 모델명, 각각 해당 모델에 대한 토크나이저와 어휘 파일을 가짐.\n",
+ " },\n",
+ " \"vocab_txt\": {\n",
+ " \"monologg/kobert\": \"https://s3.amazonaws.com/models.huggingface.co/bert/monologg/kobert/vocab.txt\",\n",
+ " \"monologg/kobert-lm\": \"https://s3.amazonaws.com/models.huggingface.co/bert/monologg/kobert-lm/vocab.txt\",\n",
+ " \"monologg/distilkobert\": \"https://s3.amazonaws.com/models.huggingface.co/bert/monologg/distilkobert/vocab.txt\"\n",
+ " }\n",
+ "}\n",
+ "\n",
+ "#KoBERT의 tokenizer와 관련된 변수들을 정의하는 부분\n",
+ "#positional embedding의 크기를 지정\n",
+ "PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES = {\n",
+ " \"monologg/kobert\": 512,\n",
+ " \"monologg/kobert-lm\": 512,\n",
+ " \"monologg/distilkobert\": 512\n",
+ "}\n",
+ "#초기화 설정값 지정.\n",
+ "PRETRAINED_INIT_CONFIGURATION = {\n",
+ " \"monologg/kobert\": {\"do_lower_case\": False}, #do_lower_case를 False로 설정하면 대소문자를 구분함.\n",
+ " \"monologg/kobert-lm\": {\"do_lower_case\": False},\n",
+ " \"monologg/distilkobert\": {\"do_lower_case\": False}\n",
+ "}\n",
+ "\n",
+ "SPIECE_UNDERLINE = u'▁'\n",
+ "#KOBERT tokenizer에서 사용되는 특수 토큰.\n",
+ "#\"__\"은 subword를 나타내며, 이는 단어 일부분이 다른 단어와 함께 subword 단위로 나눠지는 경우 사용됨.\n",
+ "\n",
+ "class KoBertTokenizer(PreTrainedTokenizer):\n",
+ " # KoBertTokenizer 클래스 : 문장 조각 기반 tokenizer를 구축하는 데 사용하는 transformer library의 PreTrainedTokenizer class를 상속받음\n",
+ " \"\"\"\n",
+ " SentencePiece based tokenizer. Peculiarities:\n",
+ " - requires `SentencePiece "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "기존 코드는 GPU에 너무 큰 부담을 줌\n",
+ "그래서 앙상블 대신 monologg/kobert 모델만 사용하되, 이전에 했떤 코드를 필사하면서 진행"
+ ],
+ "metadata": {
+ "id": "wr83NCEJ5Ddb"
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "z-OdlouOytXq",
+ "outputId": "9088b195-b68d-4c9b-b10f-43e1396ffd5b"
+ },
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
+ "Collecting torch_optimizer\n",
+ " Downloading torch_optimizer-0.3.0-py3-none-any.whl (61 kB)\n",
+ "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m61.9/61.9 kB\u001b[0m \u001b[31m315.6 kB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+ "\u001b[?25hRequirement already satisfied: torch>=1.5.0 in /usr/local/lib/python3.10/dist-packages (from torch_optimizer) (2.0.0+cu118)\n",
+ "Collecting pytorch-ranger>=0.1.1 (from torch_optimizer)\n",
+ " Downloading pytorch_ranger-0.1.1-py3-none-any.whl (14 kB)\n",
+ "Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from torch>=1.5.0->torch_optimizer) (3.12.0)\n",
+ "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.10/dist-packages (from torch>=1.5.0->torch_optimizer) (4.5.0)\n",
+ "Requirement already satisfied: sympy in /usr/local/lib/python3.10/dist-packages (from torch>=1.5.0->torch_optimizer) (1.11.1)\n",
+ "Requirement already satisfied: networkx in /usr/local/lib/python3.10/dist-packages (from torch>=1.5.0->torch_optimizer) (3.1)\n",
+ "Requirement already satisfied: jinja2 in /usr/local/lib/python3.10/dist-packages (from torch>=1.5.0->torch_optimizer) (3.1.2)\n",
+ "Requirement already satisfied: triton==2.0.0 in /usr/local/lib/python3.10/dist-packages (from torch>=1.5.0->torch_optimizer) (2.0.0)\n",
+ "Requirement already satisfied: cmake in /usr/local/lib/python3.10/dist-packages (from triton==2.0.0->torch>=1.5.0->torch_optimizer) (3.25.2)\n",
+ "Requirement already satisfied: lit in /usr/local/lib/python3.10/dist-packages (from triton==2.0.0->torch>=1.5.0->torch_optimizer) (16.0.2)\n",
+ "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2->torch>=1.5.0->torch_optimizer) (2.1.2)\n",
+ "Requirement already satisfied: mpmath>=0.19 in /usr/local/lib/python3.10/dist-packages (from sympy->torch>=1.5.0->torch_optimizer) (1.3.0)\n",
+ "Installing collected packages: pytorch-ranger, torch_optimizer\n",
+ "Successfully installed pytorch-ranger-0.1.1 torch_optimizer-0.3.0\n"
+ ]
+ }
+ ],
+ "source": [
+ "#torch_optimizer : 파이토치 기반. 딥러닝 모델 최적화를 위한 여러 알고리즘 제공\n",
+ "!pip install torch_optimizer"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "#transformers : 딥러닝 NLP 모델 구현 라이브러리\n",
+ "#사전 훈련(pre-trained) 언어 모델(LM)을 제공하고, 이후에 이걸 특정 자연어 처리 업무에 맞게 fine-tunning을 하는 것임\n",
+ "!pip install transformers"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "0R8EkYlwzrmz",
+ "outputId": "b77aefd6-904f-4df1-dd4b-094f131167a0"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
+ "Collecting transformers\n",
+ " Downloading transformers-4.28.1-py3-none-any.whl (7.0 MB)\n",
+ "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m7.0/7.0 MB\u001b[0m \u001b[31m67.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+ "\u001b[?25hRequirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from transformers) (3.12.0)\n",
+ "Collecting huggingface-hub<1.0,>=0.11.0 (from transformers)\n",
+ " Downloading huggingface_hub-0.14.1-py3-none-any.whl (224 kB)\n",
+ "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m224.5/224.5 kB\u001b[0m \u001b[31m31.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+ "\u001b[?25hRequirement already satisfied: numpy>=1.17 in /usr/local/lib/python3.10/dist-packages (from transformers) (1.22.4)\n",
+ "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.10/dist-packages (from transformers) (23.1)\n",
+ "Requirement already satisfied: pyyaml>=5.1 in /usr/local/lib/python3.10/dist-packages (from transformers) (6.0)\n",
+ "Requirement already satisfied: regex!=2019.12.17 in /usr/local/lib/python3.10/dist-packages (from transformers) (2022.10.31)\n",
+ "Requirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (from transformers) (2.27.1)\n",
+ "Collecting tokenizers!=0.11.3,<0.14,>=0.11.1 (from transformers)\n",
+ " Downloading tokenizers-0.13.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (7.8 MB)\n",
+ "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m7.8/7.8 MB\u001b[0m \u001b[31m107.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+ "\u001b[?25hRequirement already satisfied: tqdm>=4.27 in /usr/local/lib/python3.10/dist-packages (from transformers) (4.65.0)\n",
+ "Requirement already satisfied: fsspec in /usr/local/lib/python3.10/dist-packages (from huggingface-hub<1.0,>=0.11.0->transformers) (2023.4.0)\n",
+ "Requirement already satisfied: typing-extensions>=3.7.4.3 in /usr/local/lib/python3.10/dist-packages (from huggingface-hub<1.0,>=0.11.0->transformers) (4.5.0)\n",
+ "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests->transformers) (1.26.15)\n",
+ "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests->transformers) (2022.12.7)\n",
+ "Requirement already satisfied: charset-normalizer~=2.0.0 in /usr/local/lib/python3.10/dist-packages (from requests->transformers) (2.0.12)\n",
+ "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests->transformers) (3.4)\n",
+ "Installing collected packages: tokenizers, huggingface-hub, transformers\n",
+ "Successfully installed huggingface-hub-0.14.1 tokenizers-0.13.3 transformers-4.28.1\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "- pre-trained\n",
+ " - 사전 학습 모델 : 대규모 데이터셋에서 미리 학습된 모델\n",
+ " - 다른 자연어 처리 task에서도 유용하게 됨.\n",
+ " - 학습시간을 줄이고 소규모 데이터셋에서도 고성능 결과 얻을 수 있음\n",
+ "- fine-tunning\n",
+ " - 사전 훈련 모델을 사용해 특정 자연어 처리 업무에 맞는 모델을 만드는 과정"
+ ],
+ "metadata": {
+ "id": "_zb_a3cmz98y"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "# 시작"
+ ],
+ "metadata": {
+ "id": "gXcvawLJ0YIC"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "#importing libraries\n",
+ "import numpy as np\n",
+ "import os\n",
+ "import pickle\n",
+ "import sys\n",
+ "import pandas as pd\n",
+ "import re\n",
+ "import cv2"
+ ],
+ "metadata": {
+ "id": "XFgKGsjcz6J4"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "- pickle : 파이썬 객체를 직렬화/역직렬화 하기 위한 모듈. 파이썬 객체를 디스크에 저장하고 로드할 수 있는 기능\n",
+ "- sys : '인터프리터가 쓰거나 유지 및 관리하는 일부변수'와 인터프리터 간 상호작용 함수를 제공\n",
+ "- OpenCV(cv2) : 컴퓨터 비전 및 이미지 처리를 위한 라이브러리"
+ ],
+ "metadata": {
+ "id": "KYUq_8RJ0xuF"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "import torch #인공신경망 네트워크를 설계할 때 쓰는 오픈 소스 머신러닝 프레임워크, 파이토치.\n",
+ "#tensor 연산자, 인공신경망 모델, 여러 최적화 알고리즘을 제공함\n",
+ "import torch.cuda.amp as amp\n",
+ "#Automatic Mixed Precision\n",
+ "#: 단정밀도 및 반정밀도 부동 소수점 연산의 조합을 씀 -> GPU 메모리 사용량을 줄이고 학습 속도를 높임"
+ ],
+ "metadata": {
+ "id": "Og_GTAaM0VoS"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "import torch.nn as nn\n",
+ "#파이토치의 Neural Network 모듈"
+ ],
+ "metadata": {
+ "id": "MJxZWuk6wo1v"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "from torch.optim.optimizer import Optimizer, required\n",
+ "#Optimizer : 최적화 알고리즘을 파이토치에서 구현 및 사용하고자 제공되는 공통 인터페이스를 가져옴\n",
+ "#required : 함수에 필요한 인수를 지정할 때 사용되는 필수 함수를 가져옴\n",
+ "import torch_optimizer as optim\n",
+ "#torch_optimizer : 파이토치용 서드 파티 라이브러리. 추가 최적화 알고리즘을 제공함."
+ ],
+ "metadata": {
+ "id": "6kpmYkGs7QW2"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "#데이터 로딩을 위한 라이브러리들#\n",
+ "\n",
+ "\n",
+ "from torch.utils.data import DataLoader\n",
+ "#DataLoader : 파이토치 데이터셋에 대한 반복자를 제공\n",
+ "# -> 데이터셋에서 한 번에 하나의 샘플을 가져와 처리하기보다 배치 단위로 처리하는 게 효율적이라서\n",
+ "# 데이터셋의 모든 샘플을 각 반복자가 데이터셋의 한 배치를 순차적으로 반환해줌.\n",
+ "\n",
+ "from torch.utils.data.dataset import Dataset\n",
+ "#Dataset : 파이토치에서 데이터셋을 나타내는 추상 클래스\n",
+ "#데이터 샘플에 대한 액세스를 제공하기 위해 어떤 하위 클래스든지 __len__ 및 __getitem__ 두 가지 메서드를 구현해야 함\n",
+ "##그래서 이후 model 코드 작성할 때 두 메서드 구현하는 내용이 나옴.\n",
+ "\n",
+ "from torch.utils.data.sampler import *\n",
+ "#Sampler: 데이터셋에서 요소를 샘플링하는 전략을 나타내는 추상 클래스\n",
+ "# DataLoader 클래스와 함께 사용하여 데이터 로드 중 샘플링 동작을 사용자 정의할 수 있음\n",
+ "'''\n",
+ "파이토치는 RandomSampler(요소를 무작위로 샘플링),\n",
+ "SequentialSampler(요소를 순차적으로 샘플링) 및 SubsetRandomSampler(요소의 일부를 무작위로 샘플링)\n",
+ "과 같은 Sampler 클래스의 여러 구현을 제공함'''"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 54
+ },
+ "id": "ojWp5EvN0Vk4",
+ "outputId": "01bd8c0b-8224-4396-f8ec-a2fd3169893d"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "'\\n파이토치는 RandomSampler(요소를 무작위로 샘플링), \\nSequentialSampler(요소를 순차적으로 샘플링) 및 SubsetRandomSampler(요소의 일부를 무작위로 샘플링)\\n과 같은 Sampler 클래스의 여러 구현을 제공함'"
+ ],
+ "application/vnd.google.colaboratory.intrinsic+json": {
+ "type": "string"
+ }
+ },
+ "metadata": {},
+ "execution_count": 7
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "import math\n",
+ "#수학적인 함수 및 상수를 제공\n",
+ "\n",
+ "from collections import defaultdict\n",
+ "#collections.defaultdict : 기본값을 갖는 딕셔너리.\n",
+ "#딕셔너리에 존재하지 않는 키를 조회하면 딕셔너리에 있는 기본값을 반환해줌으로써\n",
+ "#KeyError를 방지하고 코드를 더 간결하게 만듦\n",
+ "\n",
+ "import itertools as it\n",
+ "#반복자(iterator)를 생성하고 연산하는 함수들의 모음\n",
+ "#반복적인 작업을 진행할 때 메모리 사용량을 최소화할 수 있음\n",
+ "\n",
+ "import tqdm\n",
+ "#진행 바 같은 걸 시각화해줌"
+ ],
+ "metadata": {
+ "id": "4B0bQfct0Via"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "import random #난수 생성, 무작위 샘플링에서 사용됨\n",
+ "import matplotlib.pyplot as plt #시각화를 위함\n",
+ "from timeit import default_timer as timer\n",
+ "#코드 실행 시간을 측정하는 함수 제공해서, 알고리즘 효율성을 파악할 수 있음"
+ ],
+ "metadata": {
+ "id": "vkgBuBXn0Vbt"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "from sklearn.model_selection import KFold #kfold\n",
+ "from sklearn.metrics import f1_score #f1-score\n",
+ "from sklearn.preprocessing import LabelEncoder #라벨인코딩.\n",
+ "from sklearn.preprocessing import StandardScaler #표준화\n",
+ "\n",
+ "from sklearn.metrics import accuracy_score #정확도 측정"
+ ],
+ "metadata": {
+ "id": "V2gPbR1R0VYN"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "#transformer 모델들과 tokenizer를 import\n",
+ "##모델들은 다 사전학습되어있음.\n",
+ "from transformers import XLMPreTrainedModel, XLMRobertaModel, XLMRobertaConfig, XLMRobertaTokenizer\n",
+ "#XLMPreTrainedModel : XLM 모델을 기반으로 하는 모든 Pretrained Model의 베이스 클래스\n",
+ "\n",
+ "\n",
+ "from transformers import XLMRobertaForSequenceClassification, BertForSequenceClassification\n",
+ "from transformers import AutoTokenizer\n",
+ "from transformers import BertForSequenceClassification, DistilBertForSequenceClassification, XLNetForSequenceClassification,\\\n",
+ "XLMRobertaForSequenceClassification, XLMForSequenceClassification, RobertaForSequenceClassification"
+ ],
+ "metadata": {
+ "id": "UoCed-c00VWH"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "#AdamW 최적화 알고리즘을 사용\n",
+ "from transformers import AdamW\n",
+ "#학습률 조절에 사용하는 함수\n",
+ "from transformers import get_linear_schedule_with_warmup"
+ ],
+ "metadata": {
+ "id": "amuHC6En0VT1"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# class args\n",
+ "class args: #여러 학습 인자의 값을 설정\n",
+ " # ---- factor ---- #\n",
+ " debug=False #디버그 모드 여부\n",
+ " amp = True #mixed precision을 사용할 지 여부\n",
+ " gpu = '0' #GPU 번호\n",
+ "\n",
+ " epochs=10 #에포크 수\n",
+ " batch_size=1 #배치 크기\n",
+ " weight_decay=1e-6 #가중치 감소 값\n",
+ " n_fold=5 #교차 검증(fold) 수\n",
+ " fold=3 # [0, 1, 2, 3, 4] # 원래는 3\n",
+ "\n",
+ " exp_name = 'experiment_name_folder'\n",
+ " dir_ = f'./saved_models/'\n",
+ " pt = 'your_model_name'\n",
+ " max_len = 33 #모델 입력 시퀀스의 최대 길이 설정\n",
+ " #학습률을 설정하는 파라미터\n",
+ " start_lr = 1e-5#1e-3,5e-5 #학습시 초기학습률 값을 의미. 학습 초기에 빠르게 수렴할 가능성이 있지만, 값이 너무 크면 수렴이 불안정해짐\n",
+ " min_lr=1e-6 #학습 중 학습율이 더이상 작아지지 않게 제한하는 값. 해당 값 이하로 떨어지지 않게 보장함.\n",
+ " # ---- Dataset ---- #\n",
+ "\n",
+ " # ---- Else ---- #\n",
+ " num_workers=8\n",
+ " seed=2021\n",
+ " scheduler = None#모델의 학습률을 조정하는 방법을 지정. 방법은 사용하지 않겠지만, 다른 변수를 이용해 학습률 조정 방식을 선택할 수 있음.\n",
+ "\n",
+ "\n",
+ "data_dir = './' # 데이터가 저장된 디렉토리 경로를 나타냄\n",
+ "os.environ[\"CUDA_VISIBLE_DEVICES\"] = args.gpu #args.gpu : 코드 실행 시 지정된 GPU의 인덱스\n",
+ "device = torch.device(f\"cuda\" if torch.cuda.is_available() else \"cpu\") #디바이스 유형 설정.\n",
+ "#만약 CUDA 디바이스가 사용 가능하면 \"cuda\"로 설정하고, 그렇지 않으면 \"cpu\"로 설정함. 이를 통해 디바이스 유형에 맞게 모델을 초기화할 수 있음.\n",
+ "\n",
+ "##모델 학습 시 랜덤 시드를 설정해 재현성을 보장\n",
+ "def set_seeds(seed=42):\n",
+ " random.seed(seed)\n",
+ " os.environ['PYTHONHASHSEED'] = str(seed)\n",
+ " np.random.seed(seed)\n",
+ " torch.manual_seed(seed)\n",
+ " torch.cuda.manual_seed(seed)\n",
+ " torch.cuda.manual_seed_all(seed)\n",
+ " #torch.backends.cudnn : NVIDIA cuDNN 라이브러리를 사용해서 PyTorch 연산의 실행 속도를 높이는 데 사용됨.\n",
+ " #cuDNN : Deep Neural Network 라이브러리, NVIDIA GPU에서 딥러닝 모델을 학습 및 추론할 때 연산속도를 높이기 위한 최적화된 기능을 제공\n",
+ " #torch.backends.cudnn을 쓰면 이런 최적화를 활용해 PyTorch 연산 속도를 높일 수 있음.\n",
+ " torch.backends.cudnn.deterministic = True #기본값이 True. 연산 실행 시간을 단축하고자 cuDNN 라이브러리가 실행 시간을 측정하고 최적화를 수행하는 걸 의미\n",
+ " torch.backends.cudnn.benchmark = False # 연산 결과가 항상 동일하지 않을 수 있다는 걸 의미함. -> 연산 속도 및 학습을 빠르게함\n",
+ "\n",
+ "set_seeds(seed=args.seed)\n"
+ ],
+ "metadata": {
+ "id": "dJFCGJZ50VRR"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# - util - #\n",
+ "def get_learning_rate(optimizer): #현재 학습률을 가져와서 반환하는 함수\n",
+ " lr=[]\n",
+ " for param_group in optimizer.param_groups:\n",
+ " #param_groups : optimizer의 학습률과 weight decay 같은 하이퍼파라미터 관리\n",
+ " lr +=[ param_group['lr'] ]\n",
+ "\n",
+ " assert(len(lr)==1)\n",
+ " #'lr'의 길이가 1인지 확인하는데, 이건 현재 이 코드에서 하나의 학습률만 사용하기 때문임.\n",
+ " lr = lr[0]\n",
+ "\n",
+ " return lr\n",
+ "\n",
+ "def load_data(): #데이터 로드 합수\n",
+ " train=pd.read_csv('./train_data.csv')\n",
+ " test=pd.read_csv('./test_data.csv')\n",
+ "\n",
+ " #일부 column을 지정\n",
+ " train=train[['title','topic_idx']]\n",
+ " test=test[['title']]\n",
+ " #5-fold 교차 검증 수행\n",
+ " from sklearn.model_selection import StratifiedKFold\n",
+ " skf = StratifiedKFold(n_splits=5, random_state=42, shuffle=True)\n",
+ " train['fold'] = -1\n",
+ " for n_fold, (_,v_idx) in enumerate(skf.split(train, train['topic_idx'])):\n",
+ " train.loc[v_idx, 'fold'] = n_fold\n",
+ " #train 데이터에 fold와 id열을 추가\n",
+ " train['id'] = [x for x in range(len(train))]\n",
+ "\n",
+ " return train, test"
+ ],
+ "metadata": {
+ "id": "_xjzqVpL0VOu"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "# 전처리"
+ ],
+ "metadata": {
+ "id": "dmD4Lb5YgyoF"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# make KoBertTokenizer\n",
+ "# 한글을 토큰화할 수 있는 KoBert 모델용 custom tokenizer를 만드는 데 사용함.\n",
+ "import logging\n",
+ "import os\n",
+ "import unicodedata #유니코드 문자 처리를 위함\n",
+ "from shutil import copyfile #파일 복사\n",
+ "\n",
+ "from transformers import PreTrainedTokenizer\n",
+ "\n",
+ "logger = logging.getLogger(__name__)\n",
+ "#logger : 스크립트 실행되는 동안 메세지를 기록하는 데 사용함.\n",
+ "# 로거명을 __name__로 설정하면 현재 모듈명을 로거의 이름으로 사용함\n",
+ "# 이렇게 하면 각 모듈이 자체 로거를 가질 수 있으므로 대규모 애플리케이션에서 로그 메세지를 더 잘 구성할 수 있음.\n",
+ "\n",
+ "VOCAB_FILES_NAMES = {\"vocab_file\": \"tokenizer_78b3253a26.model\", # 어휘파일의 위치 지정\n",
+ " \"vocab_txt\": \"vocab.txt\"} # 어휘에 대한 토큰-index mapping 사전을 구축하는 데 쓰임.\n",
+ "#PRETRAINED_VOCAB_FILES_MAP 변수를 정의하는 코드\n",
+ "# hugging face의 transformer 라이브러리에서 사용되고, 사전 학습된 모델의 tokenizer와 관련된 파일들의 URL을 매핑함\n",
+ "#즉, 해당 모델에 대한 토크나이저와 어휘파일을 쉽게 다운로드할 수 있음.\n",
+ "PRETRAINED_VOCAB_FILES_MAP = {\n",
+ " #vocab_file과 vocab_txt는 각각 토크나이저 파이과 어휘 파일의 URL을 가리키는 사전임\n",
+ " \"vocab_file\": {\n",
+ " \"monologg/kobert\": \"https://s3.amazonaws.com/models.huggingface.co/bert/monologg/kobert/tokenizer_78b3253a26.model\",\n",
+ " #각각의 어휘파일의 링크가 제공됨.\n",
+ " #이 링크들은 Hugging Face에서 제공하는 S3 버킷에서 해당 어휘 파일을 다운로드할 수 있는 주소를 제공함.\n",
+ " \"monologg/kobert-lm\": \"https://s3.amazonaws.com/models.huggingface.co/bert/monologg/kobert-lm/tokenizer_78b3253a26.model\",\n",
+ " \"monologg/distilkobert\": \"https://s3.amazonaws.com/models.huggingface.co/bert/monologg/distilkobert/tokenizer_78b3253a26.model\"\n",
+ " #세 개의 다른 모델명, 각각 해당 모델에 대한 토크나이저와 어휘 파일을 가짐.\n",
+ " },\n",
+ " \"vocab_txt\": {\n",
+ " \"monologg/kobert\": \"https://s3.amazonaws.com/models.huggingface.co/bert/monologg/kobert/vocab.txt\",\n",
+ " \"monologg/kobert-lm\": \"https://s3.amazonaws.com/models.huggingface.co/bert/monologg/kobert-lm/vocab.txt\",\n",
+ " \"monologg/distilkobert\": \"https://s3.amazonaws.com/models.huggingface.co/bert/monologg/distilkobert/vocab.txt\"\n",
+ " }\n",
+ "}\n",
+ "\n",
+ "#KoBERT의 tokenizer와 관련된 변수들을 정의하는 부분\n",
+ "#positional embedding의 크기를 지정\n",
+ "PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES = {\n",
+ " \"monologg/kobert\": 512,\n",
+ " \"monologg/kobert-lm\": 512,\n",
+ " \"monologg/distilkobert\": 512\n",
+ "}\n",
+ "#초기화 설정값 지정.\n",
+ "PRETRAINED_INIT_CONFIGURATION = {\n",
+ " \"monologg/kobert\": {\"do_lower_case\": False}, #do_lower_case를 False로 설정하면 대소문자를 구분함.\n",
+ " \"monologg/kobert-lm\": {\"do_lower_case\": False},\n",
+ " \"monologg/distilkobert\": {\"do_lower_case\": False}\n",
+ "}\n",
+ "\n",
+ "SPIECE_UNDERLINE = u'▁'\n",
+ "#KOBERT tokenizer에서 사용되는 특수 토큰.\n",
+ "#\"__\"은 subword를 나타내며, 이는 단어 일부분이 다른 단어와 함께 subword 단위로 나눠지는 경우 사용됨.\n",
+ "\n",
+ "class KoBertTokenizer(PreTrainedTokenizer):\n",
+ " # KoBertTokenizer 클래스 : 문장 조각 기반 tokenizer를 구축하는 데 사용하는 transformer library의 PreTrainedTokenizer class를 상속받음\n",
+ " \"\"\"\n",
+ " SentencePiece based tokenizer. Peculiarities:\n",
+ " - requires `SentencePiece