Initial commit after clean up

.gitattributes

@@ -0,0 +1,36 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+images/*.jpg filter=lfs diff=lfs merge=lfs -text

.vscode/extensions.json

@@ -0,0 +1,5 @@
+{
+    "recommendations": [
+        "ms-python.black-formatter"
+    ]
+}

1장 허깅페이스 알아보기/예제 1.01 파이토치 GPU 가속 확인.ipynb

@@ -0,0 +1,58 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "95ff9559-b7e7-401f-9b73-8c7a68eed848",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2.7.1+cu118\n",
+      "True\n",
+      "파이썬 경로: /home/ufslab223/anaconda3/envs/hface/bin/python\n",
+      "파이토치 버전: 2.7.1+cu118\n",
+      "파이토치 설치 경로: /home/ufslab223/anaconda3/envs/hface/lib/python3.11/site-packages/torch/__init__.py\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch\n",
+    "\n",
+    "print(torch.__version__)\n",
+    "print(torch.cuda.is_available())\n",
+    "\n",
+    "\n",
+    "import sys\n",
+    "import torch\n",
+    "\n",
+    "print(f\"파이썬 경로: {sys.executable}\")\n",
+    "print(f\"파이토치 버전: {torch.__version__}\")\n",
+    "print(f\"파이토치 설치 경로: {torch.__file__}\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "hface",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.15"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

1장 허깅페이스 알아보기/예제 1.02 MPS 가속 확인.ipynb

@@ -0,0 +1,49 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "95ff9559-b7e7-401f-9b73-8c7a68eed848",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2.5.1\n",
+      "False\n",
+      "False\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch\n",
+    "\n",
+    "print(torch.__version__)\n",
+    "print(torch.backends.mps.is_built())\n",
+    "print(torch.backends.mps.is_available())"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "hface",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.15"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

1장 허깅페이스 알아보기/예제 1.03 파이토치 GPU 가속 확인.ipynb

@@ -0,0 +1,38 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "95ff9559-b7e7-401f-9b73-8c7a68eed848",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "\n",
+    "print(torch.__version__)\n",
+    "print(torch.cuda.is_available())"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

1장 허깅페이스 알아보기/예제 1.04 resnet-18 샘플 코드.ipynb

@@ -0,0 +1,52 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "95ff9559-b7e7-401f-9b73-8c7a68eed848",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from transformers import AutoImageProcessor, AutoModelForImageClassification\n",
+    "import torch\n",
+    "from datasets import load_dataset\n",
+    "\n",
+    "dataset = load_dataset(\"huggingface/cats-image\", trust_remote_code=True)\n",
+    "image = dataset[\"test\"][\"image\"][0]\n",
+    "\n",
+    "image_processor = AutoImageProcessor.from_pretrained(\"microsoft/resnet-18\")\n",
+    "model = AutoModelForImageClassification.from_pretrained(\"microsoft/resnet-18\")\n",
+    "\n",
+    "inputs = image_processor(image, return_tensors=\"pt\")\n",
+    "\n",
+    "with torch.no_grad():\n",
+    "    logits = model(**inputs).logits\n",
+    "\n",
+    "# model predicts one of the 1000 ImageNet classes\n",
+    "predicted_label = logits.argmax(-1).item()\n",
+    "print(model.config.id2label[predicted_label])"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

1장 허깅페이스 알아보기/예제 1.05 push_to_hub 메서드 업로드.ipynb

@@ -0,0 +1,80 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "95ff9559-b7e7-401f-9b73-8c7a68eed848",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from transformers import AutoImageProcessor, AutoModelForImageClassification\n",
+    "import torch\n",
+    "from datasets import load_dataset\n",
+    "\n",
+    "dataset = load_dataset(\"huggingface/cats-image\", trust_remote_code=True)\n",
+    "image = dataset[\"test\"][\"image\"][0]\n",
+    "\n",
+    "image_processor = AutoImageProcessor.from_pretrained(\"microsoft/resnet-18\")\n",
+    "model = AutoModelForImageClassification.from_pretrained(\"microsoft/resnet-18\")\n",
+    "\n",
+    "inputs = image_processor(image, return_tensors=\"pt\")\n",
+    "\n",
+    "with torch.no_grad():\n",
+    "    logits = model(**inputs).logits\n",
+    "\n",
+    "# model predicts one of the 1000 ImageNet classes\n",
+    "predicted_label = logits.argmax(-1).item()\n",
+    "print(model.config.id2label[predicted_label])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fb8c6599",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "REPO_ID = \"모델 리포지터리 이름 입력\" # resnet-18\n",
+    "TOKEN = \"토큰 이름 입력\" # hf_..."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4d95cf8a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "image_processor.push_to_hub(\n",
+    "    repo_id=REPO_ID,\n",
+    "    token=TOKEN\n",
+    ")\n",
+    "model.push_to_hub(\n",
+    "    repo_id=REPO_ID,\n",
+    "    token=TOKEN\n",
+    ")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

2장 허깅페이스 트랜스포머/예제 2.01 PretrainedConfig 클래스.ipynb

@@ -0,0 +1,48 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "39d707db",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from transformers import PretrainedConfig\n",
+    "\n",
+    "config = PretrainedConfig(\n",
+    "    model_type=\"bert\",\n",
+    "    vocab_size=30522,\n",
+    "    hidden_size=768,\n",
+    "    num_attention_heads=12,\n",
+    "    num_hidden_layers=12,\n",
+    "    intermediate_size=3072,\n",
+    "    hidden_act=\"gelu\",\n",
+    "    hidden_dropout_prob=0.1,\n",
+    "    initializer_range=0.02\n",
+    ")\n",
+    "print(config)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

2장 허깅페이스 트랜스포머/예제 2.02 PretrainedConfig 클래스의 from_pretrained 메서드.ipynb

@@ -0,0 +1,42 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "39d707db",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from transformers import PretrainedConfig\n",
+    "\n",
+    "config = PretrainedConfig.from_pretrained(\n",
+    "    pretrained_model_name_or_path=\"google-bert/bert-base-uncased\",\n",
+    "    hidden_act=\"swish\"\n",
+    ")\n",
+    "\n",
+    "print(config)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

2장 허깅페이스 트랜스포머/예제 2.03 BertConfig 클래스.ipynb

@@ -0,0 +1,42 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "39d707db",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from transformers import BertConfig\n",
+    "\n",
+    "config = BertConfig(\n",
+    "    num_hidden_layers=12, \n",
+    "    num_attention_heads=12\n",
+    ")\n",
+    "\n",
+    "print(config)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

2장 허깅페이스 트랜스포머/예제 2.04 BertTokenizer 클래스.ipynb

@@ -0,0 +1,42 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "39d707db",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from transformers import BertTokenizer\n",
+    "\n",
+    "tokenizer = BertTokenizer.from_pretrained(\"bert-base-uncased\")\n",
+    "text = \"I am learning about tokenizers.\"\n",
+    "encoded = tokenizer.encode(text, add_special_tokens=True)\n",
+    "\n",
+    "print(encoded)\n",
+    "print(tokenizer.decode(encoded))"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

2장 허깅페이스 트랜스포머/예제 2.05 BertModel 클래스.ipynb

@@ -0,0 +1,44 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "39d707db",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from transformers import BertTokenizer, BertModel\n",
+    "\n",
+    "tokenizer = BertTokenizer.from_pretrained(\"bert-base-uncased\")\n",
+    "text = \"I am learning about tokenizers.\"\n",
+    "input = tokenizer(text, return_tensors=\"pt\")\n",
+    "print(input)\n",
+    "\n",
+    "model = BertModel.from_pretrained(\"bert-base-uncased\")\n",
+    "output = model(**input)\n",
+    "print(output.last_hidden_state.shape)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

2장 허깅페이스 트랜스포머/예제 2.06 BertForMaskedLM 클래스.ipynb

@@ -0,0 +1,54 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "39d707db",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "from torch.nn import functional as F\n",
+    "from transformers import BertTokenizer, BertForMaskedLM\n",
+    "\n",
+    "tokenizer = BertTokenizer.from_pretrained(\"bert-base-uncased\")\n",
+    "model = BertForMaskedLM.from_pretrained(\"bert-base-uncased\", return_dict=True)\n",
+    "\n",
+    "text = f\"I {tokenizer.mask_token} learning about tokenizers.\"\n",
+    "input = tokenizer(text, return_tensors=\"pt\")\n",
+    "output = model(**input)\n",
+    "\n",
+    "mask_index = torch.where(input[\"input_ids\"][0] == tokenizer.mask_token_id)\n",
+    "softmax = F.softmax(output.logits, dim=-1)\n",
+    "mask_word = softmax[0, mask_index, :]\n",
+    "top10 = torch.topk(mask_word, 10, dim=1)[1][0]\n",
+    "\n",
+    "for token in top10:\n",
+    "    word = tokenizer.decode([token])\n",
+    "    sentence = text.replace(tokenizer.mask_token, word)\n",
+    "    print(sentence)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

2장 허깅페이스 트랜스포머/예제 2.07 CLIPFeatureExtractor 클래스.ipynb

@@ -0,0 +1,52 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "39d707db",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from datasets import load_dataset\n",
+    "from transformers import CLIPFeatureExtractor\n",
+    "\n",
+    "dataset = load_dataset(\"huggingface/cats-image\")\n",
+    "image = dataset[\"test\"][\"image\"][0]\n",
+    "\n",
+    "feature_extractor = CLIPFeatureExtractor.from_pretrained(\"openai/clip-vit-base-patch32\")\n",
+    "inputs = feature_extractor(\n",
+    "    images=image,\n",
+    "    do_resize=True,\n",
+    "    size=512,\n",
+    "    do_center_crop=True,\n",
+    "    crop_size=512,\n",
+    "    return_tensors=\"pt\"\n",
+    ")\n",
+    "\n",
+    "print(inputs[\"pixel_values\"].shape)\n",
+    "print(inputs)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

2장 허깅페이스 트랜스포머/예제 2.08 Wav2Vec2FeatureExtractor 클래스.ipynb

@@ -0,0 +1,61 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "76155e63",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!pip install soundfile librosa"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "39d707db",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from datasets import load_dataset\n",
+    "from transformers import Wav2Vec2FeatureExtractor\n",
+    "\n",
+    "dataset = load_dataset(\"PolyAI/minds14\", \"ko-KR\", split=\"train\", trust_remote_code=True)\n",
+    "audios = [audio[\"array\"] for audio in dataset[\"audio\"][:2]]\n",
+    "\n",
+    "feature_extractor = Wav2Vec2FeatureExtractor.from_pretrained(\"facebook/wav2vec2-base-960h\")\n",
+    "inputs = feature_extractor(\n",
+    "    raw_speech=audios,\n",
+    "    padding=True,\n",
+    "    return_attention_mask=True,\n",
+    "    return_tensors=\"pt\"\n",
+    ")\n",
+    "\n",
+    "print(inputs[\"input_values\"][0].shape)\n",
+    "print(inputs[\"input_values\"][1].shape)\n",
+    "print(inputs)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

2장 허깅페이스 트랜스포머/예제 2.09 CLIPImageProcessor 클래스.ipynb

@@ -0,0 +1,51 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "39d707db",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from datasets import load_dataset\n",
+    "from transformers import CLIPImageProcessor\n",
+    "\n",
+    "dataset = load_dataset(\"huggingface/cats-image\")\n",
+    "image = dataset[\"test\"][\"image\"][0]\n",
+    "\n",
+    "image_processor = CLIPImageProcessor.from_pretrained(\"openai/clip-vit-base-patch32\")\n",
+    "pixel_values = image_processor(\n",
+    "    images=image,\n",
+    "    image_mean=[0.48145466, 0.4578275, 0.40821073],\n",
+    "    image_std=[0.26862954, 0.26130258, 0.27577711],\n",
+    "    do_convert_rgb=True,\n",
+    "    return_tensors=\"pt\"\n",
+    ")\n",
+    "\n",
+    "print(pixel_values[\"pixel_values\"].shape)\n",
+    "print(pixel_values)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

2장 허깅페이스 트랜스포머/예제 2.10 오토 클래스로 자연어 처리 모델 불러오기.ipynb

@@ -0,0 +1,45 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "39d707db",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from transformers import AutoModel, AutoTokenizer\n",
+    "\n",
+    "model_name = \"bert-base-uncased\"\n",
+    "tokenizer = AutoTokenizer.from_pretrained(model_name)\n",
+    "model = AutoModel.from_pretrained(model_name)\n",
+    "\n",
+    "text = \"I am learning about tokenizers.\"\n",
+    "input = tokenizer(text, return_tensors=\"pt\")\n",
+    "output = model(**input)\n",
+    "\n",
+    "print(output.last_hidden_state.shape)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

2장 허깅페이스 트랜스포머/예제 2.11 오토 클래스로 컴퓨터 비전 모델 불러오기.ipynb

@@ -0,0 +1,49 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "39d707db",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from PIL import Image\n",
+    "from datasets import load_dataset\n",
+    "from transformers import AutoImageProcessor, AutoModel\n",
+    "\n",
+    "model_name = \"microsoft/resnet-18\" # \"google/vit-base-patch16-224-in21k\"\n",
+    "image_processor = AutoImageProcessor.from_pretrained(model_name)\n",
+    "model = AutoModel.from_pretrained(model_name)\n",
+    "\n",
+    "dataset = load_dataset(\"huggingface/cats-image\")\n",
+    "image = dataset[\"test\"][\"image\"][0]\n",
+    "\n",
+    "inputs = image_processor(images=image, return_tensors=\"pt\")\n",
+    "outputs = model(**inputs)\n",
+    "\n",
+    "print(outputs.last_hidden_state.shape)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

2장 허깅페이스 트랜스포머/예제 2.12 오토 클래스로 오디오 모델 불러오기.ipynb

@@ -0,0 +1,45 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "39d707db",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from datasets import load_dataset\n",
+    "from transformers import AutoFeatureExtractor\n",
+    "\n",
+    "model_name = \"facebook/wav2vec2-base-960h\" # \"openai/whisper-tiny\"\n",
+    "feature_extractor = AutoFeatureExtractor.from_pretrained(model_name)\n",
+    "\n",
+    "dataset = load_dataset(\"PolyAI/minds14\", \"ko-KR\", split=\"train\")\n",
+    "audios = [audio[\"array\"] for audio in dataset[\"audio\"][:2]]\n",
+    "\n",
+    "inputs = feature_extractor(raw_speech=audios, padding=True, return_tensors=\"pt\")\n",
+    "print(inputs.keys())"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

2장 허깅페이스 트랜스포머/예제 2.13 자연어 처리 파이프라인 예시 (1).ipynb

@@ -0,0 +1,69 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "39d707db",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import torch.nn.functional as F\n",
+    "from transformers import pipeline\n",
+    "\n",
+    "pipe = pipeline(\n",
+    "    task=\"text-classification\",\n",
+    "    model=\"cardiffnlp/twitter-roberta-base-sentiment-latest\"\n",
+    ")\n",
+    "raw_text = [\n",
+    "    \"I love you.\",\n",
+    "    \"I hate you.\",\n",
+    "    \"I meet with you.\"\n",
+    "]\n",
+    "\n",
+    "inputs = pipe.tokenizer(raw_text, padding=True, return_tensors=\"pt\")\n",
+    "outputs = pipe.model(inputs[\"input_ids\"])\n",
+    "probabilities = F.softmax(outputs.logits, dim=1)\n",
+    "prediction = []\n",
+    "for prob in probabilities:\n",
+    "    max_idx = torch.argmax(prob).item()\n",
+    "    class_name = pipe.model.config.id2label[max_idx]\n",
+    "    score = prob[max_idx].item()\n",
+    "    prediction.append({\"label\": class_name, \"score\": score})\n",
+    "\n",
+    "print(\"- raw text:\")\n",
+    "print(raw_text)\n",
+    "\n",
+    "print(\"- input_ids:\")\n",
+    "print(inputs[\"input_ids\"])\n",
+    "\n",
+    "print(\"- logits:\")\n",
+    "print(outputs[\"logits\"])\n",
+    "\n",
+    "print(\"- prediction:\")\n",
+    "print(prediction)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

2장 허깅페이스 트랜스포머/예제 2.14 자연어 처리 파이프라인 예시 (2).ipynb

@@ -0,0 +1,47 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "39d707db",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from transformers import pipeline\n",
+    "\n",
+    "pipe = pipeline(\n",
+    "    task=\"text-classification\",\n",
+    "    model=\"cardiffnlp/twitter-roberta-base-sentiment-latest\"\n",
+    ")\n",
+    "raw_text = [\n",
+    "    \"I love you.\",\n",
+    "    \"I hate you.\",\n",
+    "    \"I meet with you.\"\n",
+    "]\n",
+    "prediction = pipe(raw_text)\n",
+    "print(prediction)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

2장 허깅페이스 트랜스포머/예제 2.15 자연어 처리 파이프라인.ipynb

@@ -0,0 +1,46 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "39d707db",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "from transformers import pipeline\n",
+    "\n",
+    "pipe = pipeline(\n",
+    "    task=\"text-generation\",\n",
+    "    model=\"openai-community/gpt2\", # google-bert/bert-base-uncased\n",
+    "    device=torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\"),\n",
+    "    torch_dtype=torch.bfloat16\n",
+    ")\n",
+    "inputs = \"I am learning about tokenizers.\"\n",
+    "outputs = pipe(inputs)\n",
+    "print(outputs)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

2장 허깅페이스 트랜스포머/예제 2.16 컴퓨터 비전 파이프라인.ipynb

@@ -0,0 +1,49 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "39d707db",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from datasets import load_dataset\n",
+    "from transformers import pipeline\n",
+    "\n",
+    "pipe = pipeline(\n",
+    "    task=\"image-classification\",\n",
+    "    model=\"google/vit-base-patch16-224\",\n",
+    "    model_kwargs={\n",
+    "        \"hidden_act\": \"gelu\" # relu\n",
+    "    }\n",
+    ")\n",
+    "\n",
+    "dataset = load_dataset(\"huggingface/cats-image\")\n",
+    "inputs = dataset[\"test\"][\"image\"][0]\n",
+    "outputs = pipe(inputs)\n",
+    "print(outputs)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

2장 허깅페이스 트랜스포머/예제 2.17 데이터세트 불러오기 (1).ipynb

@@ -0,0 +1,41 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "39d707db",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from datasets import load_dataset\n",
+    "\n",
+    "dataset1 = load_dataset(path=\"squad\")\n",
+    "dataset2 = load_dataset(path=\"squad\", split=\"train[:10]+validation[:10]\")\n",
+    "\n",
+    "print(dataset1)\n",
+    "print(dataset2)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

2장 허깅페이스 트랜스포머/예제 2.18 데이터세트 불러오기 (2).ipynb

@@ -0,0 +1,43 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "39d707db",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from datasets import load_dataset\n",
+    "\n",
+    "dataset1 = load_dataset(path=\"../datasets\")\n",
+    "dataset2 = load_dataset(path=\"json\", data_dir=\"../datasets\")\n",
+    "dataset3 = load_dataset(path=\"json\", data_files={\"train\": \"../datasets/train.jsonl\", \"validation\": \"../datasets/val.jsonl\"})\n",
+    "\n",
+    "print(dataset1[\"train\"][0])\n",
+    "print(dataset2[\"train\"][0])\n",
+    "print(dataset3[\"train\"][0])"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

2장 허깅페이스 트랜스포머/예제 2.19 데이터세트 선택, 분리, 병합.ipynb

@@ -0,0 +1,48 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "39d707db",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from datasets import load_dataset\n",
+    "from datasets import concatenate_datasets\n",
+    "\n",
+    "dataset = load_dataset(\"squad\", split=\"train[:10]\")\n",
+    "\n",
+    "chunk1 = dataset.select([0, 1])\n",
+    "chunk2 = dataset.shard(num_shards=2, index=0)\n",
+    "chunk3 = dataset.shard(num_shards=2, index=1)\n",
+    "concat_dataset = concatenate_datasets([chunk1, chunk2, chunk3])\n",
+    "\n",
+    "print(len(chunk1))\n",
+    "print(len(chunk2))\n",
+    "print(len(chunk3))\n",
+    "print(len(concat_dataset))"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

2장 허깅페이스 트랜스포머/예제 2.20 데이터세트 filter와 map 메서드.ipynb

@@ -0,0 +1,69 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "39d707db",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from datasets import load_dataset\n",
+    "from transformers import BertTokenizer\n",
+    "\n",
+    "def filter_short_context(data):\n",
+    "    return len(data[\"context\"]) <= 1024\n",
+    "\n",
+    "def tokenize_function(tokenizer, data):\n",
+    "    inputs = [\n",
+    "        f\"{question} [SEP] {context}\"\n",
+    "        for question, context in zip(data[\"question\"], data[\"context\"])\n",
+    "    ]\n",
+    "    model_inputs = tokenizer(\n",
+    "        inputs,\n",
+    "        max_length=512,\n",
+    "        padding=\"max_length\",\n",
+    "        truncation=True,\n",
+    "        return_tensors=\"pt\"\n",
+    "    )\n",
+    "    return model_inputs\n",
+    "\n",
+    "dataset = load_dataset(\"squad\", split=\"train[:10]\")\n",
+    "tokenizer = BertTokenizer.from_pretrained(\"bert-base-uncased\")\n",
+    "\n",
+    "filtered_dataset = dataset.filter(filter_short_context)\n",
+    "tokenized_dataset = filtered_dataset.map(\n",
+    "    lambda x: tokenize_function(tokenizer, x),\n",
+    "    batched=True,\n",
+    "    remove_columns=dataset.column_names\n",
+    ")\n",
+    "tokenized_dataset.set_format(\n",
+    "    type=\"torch\",\n",
+    "    columns=[\"input_ids\", \"token_type_ids\", \"attention_mask\"]\n",
+    ")\n",
+    "print(tokenized_dataset)\n",
+    "print(tokenized_dataset[0])"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

2장 허깅페이스 트랜스포머/예제 2.21 데이터세트 업로드.ipynb

@@ -0,0 +1,62 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "39d707db",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "from collections import defaultdict\n",
+    "from datasets import Dataset, Image, DatasetDict\n",
+    "\n",
+    "data = defaultdict(list)\n",
+    "folder_name = \"../images\"\n",
+    "for file_name in os.listdir(folder_name):\n",
+    "    name = os.path.splitext(file_name)[0]\n",
+    "    path = os.path.join(folder_name, file_name)\n",
+    "\n",
+    "    data[\"name\"].append(name)\n",
+    "    data[\"image\"].append(path)\n",
+    "\n",
+    "dataset = Dataset.from_dict(data).cast_column(\"image\", Image())\n",
+    "print(data)\n",
+    "print(dataset[0])\n",
+    "\n",
+    "datasetdict = DatasetDict(\n",
+    "    {\n",
+    "        \"train\": dataset.select(range(5)),\n",
+    "        \"valid\": dataset.select(range(5, 10)),\n",
+    "        \"test\": dataset.select(range(10, len(dataset)))\n",
+    "    }\n",
+    ")\n",
+    "\n",
+    "hub_name = \"<user_name>/<repo_name>\" # 데이터세트 저장소 경로 입력\n",
+    "token = \"hf_###...\" # 토큰 입력\n",
+    "datasetdict.push_to_hub(hub_name, token=token)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

2장 허깅페이스 트랜스포머/예제 2.22 ~ 2.26 개체명 인식 모델.ipynb

@@ -0,0 +1,150 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "39d707db",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from datasets import load_dataset\n",
+    "from transformers import AutoModelForTokenClassification, AutoTokenizer\n",
+    "\n",
+    "dataset = load_dataset(\"klue\", \"ner\")\n",
+    "labels = dataset[\"train\"].features[\"ner_tags\"].feature.names\n",
+    "\n",
+    "model_name = \"Leo97/KoELECTRA-small-v3-modu-ner\"\n",
+    "tokenizer = AutoTokenizer.from_pretrained(model_name)\n",
+    "model = AutoModelForTokenClassification.from_pretrained(\n",
+    "    model_name,\n",
+    "    num_labels=len(labels),\n",
+    "    ignore_mismatched_sizes=True\n",
+    ")\n",
+    "\n",
+    "print(dataset[\"train\"])\n",
+    "print(dataset[\"train\"][0])\n",
+    "print(labels)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "56149149",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def preprocess_data(example, tokenizer):\n",
+    "    sentence = \"\".join(example[\"tokens\"]).replace(\"\\xa0\", \" \")\n",
+    "    encoded = tokenizer(\n",
+    "        sentence,\n",
+    "        return_offsets_mapping=True,\n",
+    "        add_special_tokens=False,\n",
+    "        padding=False,\n",
+    "        truncation=False\n",
+    "    )\n",
+    "\n",
+    "    labels = []\n",
+    "    for offset in encoded.offset_mapping:\n",
+    "        if offset[0] == offset[1]:\n",
+    "            labels.append(-100)\n",
+    "        else:\n",
+    "            labels.append(example[\"ner_tags\"][offset[0]])\n",
+    "    encoded[\"labels\"] = labels\n",
+    "    return encoded\n",
+    "\n",
+    "\n",
+    "processed_dataset = dataset.map(\n",
+    "    lambda example: preprocess_data(example, tokenizer),\n",
+    "    batched=False,\n",
+    "    remove_columns=dataset[\"train\"].column_names\n",
+    ")\n",
+    "print(processed_dataset)\n",
+    "print(dataset[\"train\"][0][\"ner_tags\"])\n",
+    "print(processed_dataset[\"train\"][0][\"offset_mapping\"])\n",
+    "print(processed_dataset[\"train\"][0][\"labels\"])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f0aac748",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from transformers import Trainer, TrainingArguments\n",
+    "from transformers.data.data_collator import DataCollatorForTokenClassification\n",
+    "\n",
+    "training_args = TrainingArguments(\n",
+    "    output_dir=\"token-classification\",\n",
+    "    evaluation_strategy=\"epoch\",\n",
+    "    per_device_train_batch_size=32,\n",
+    "    per_device_eval_batch_size=32,\n",
+    "    learning_rate=1e-4,\n",
+    "    weight_decay=0.01,\n",
+    "    num_train_epochs=5,\n",
+    "    seed=42\n",
+    ")\n",
+    "\n",
+    "trainer = Trainer(\n",
+    "    model=model,\n",
+    "    args=training_args,\n",
+    "    train_dataset=processed_dataset[\"train\"],\n",
+    "    eval_dataset=processed_dataset[\"validation\"],\n",
+    "    data_collator=DataCollatorForTokenClassification(tokenizer=tokenizer, padding=True)\n",
+    ")\n",
+    "\n",
+    "trainer.train()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ab38d1e5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "\n",
+    "model.eval()\n",
+    "text = \"위키북스의 윤대희, 김동화, 송종민 그리고 진현두는 2025년 서울에서 2시간 동안 신간 1권에 관한 논의를 진행했다.\"\n",
+    "\n",
+    "with torch.no_grad():\n",
+    "    tokenized = tokenizer(\n",
+    "        text,\n",
+    "        return_tensors=\"pt\",\n",
+    "        padding=True,\n",
+    "        truncation=True,\n",
+    "        max_length=512,\n",
+    "        add_special_tokens=False\n",
+    "    )\n",
+    "    logits = model(**tokenized.to(\"cuda\")).logits.cpu()\n",
+    "\n",
+    "predictions = logits.argmax(dim=-1)[0].tolist()\n",
+    "tokens = tokenizer.tokenize(text)\n",
+    "\n",
+    "print(list(zip(tokens, [labels[i] for i in predictions])))"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

2장 허깅페이스 트랜스포머/예제 2.27 이미지 모델 평가 수행.ipynb

@@ -0,0 +1,80 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e41fc33d",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import evaluate\n",
+    "import numpy as np\n",
+    "from datasets import load_dataset\n",
+    "from transformers import AutoImageProcessor, AutoModelForImageClassification\n",
+    "\n",
+    "dataset = load_dataset(\"cifar10\", split=\"test[:1000]\")\n",
+    "model_name = \"nateraw/vit-base-patch16-224-cifar10\"\n",
+    "model = AutoModelForImageClassification.from_pretrained(model_name)\n",
+    "image_processor = AutoImageProcessor.from_pretrained(model_name)\n",
+    "\n",
+    "model.eval()\n",
+    "batch_size = 32\n",
+    "logits, labels = [], []\n",
+    "\n",
+    "for i in range(0, len(dataset), batch_size):\n",
+    "    batch = dataset[i : i + batch_size]\n",
+    "\n",
+    "    with torch.no_grad():\n",
+    "        inputs = image_processor(batch[\"img\"], return_tensors=\"pt\")\n",
+    "        outputs = model(inputs[\"pixel_values\"])\n",
+    "\n",
+    "    logits.extend(outputs.logits.cpu().numpy())\n",
+    "    labels.extend(batch[\"label\"])\n",
+    "\n",
+    "preds = np.argmax(logits, axis=-1)\n",
+    "\n",
+    "metric = evaluate.load(\"accuracy\")\n",
+    "accuracy = metric.compute(predictions=preds, references=labels)\n",
+    "print(accuracy)\n",
+    "\n",
+    "metric = evaluate.load(\"f1\")\n",
+    "f1 = metric.compute(predictions=preds, references=labels, average=\"macro\")\n",
+    "print(f1)\n",
+    "\n",
+    "comparison = evaluate.load(\"exact_match\", module_type=\"comparison\")\n",
+    "exact_match = comparison.compute(predictions1=preds, predictions2=labels)\n",
+    "print(exact_match)\n",
+    "\n",
+    "measurement = evaluate.load(\"label_distribution\", module_type=\"measurement\")\n",
+    "distribution = measurement.compute(data=labels)\n",
+    "print(distribution)\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

2장 허깅페이스 트랜스포머/예제 2.28 레이더 차트 시각화.ipynb

@@ -0,0 +1,50 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e41fc33d",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "from evaluate.visualization import radar_plot\n",
+    "\n",
+    "data = [\n",
+    "   {\"accuracy\": 0.49, \"precision\": 0.50, \"f1\": 0.49, \"latency_in_seconds\": 0.15},\n",
+    "   {\"accuracy\": 0.92, \"precision\": 0.93, \"f1\": 0.92, \"latency_in_seconds\": 0.10},\n",
+    "   {\"accuracy\": 0.68, \"precision\": 0.70, \"f1\": 0.68, \"latency_in_seconds\": 0.12}, \n",
+    "   {\"accuracy\": 0.78, \"precision\": 0.80, \"f1\": 0.78, \"latency_in_seconds\": 0.11}\n",
+    "]\n",
+    "\n",
+    "model_names = [\"Model 1\", \"Model 2\", \"Model 3\", \"Model 4\"]\n",
+    "plot = radar_plot(data=data, model_names=model_names)\n",
+    "plot.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

3장 자연어 처리/예제 3.01 BERT 토크나이저를 이용한 토큰화.ipynb

@@ -0,0 +1,49 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e41fc33d",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "from transformers import BertTokenizer\n",
+    "\n",
+    "tokenizer = BertTokenizer.from_pretrained(\"google-bert/bert-base-multilingual-uncased\")\n",
+    "\n",
+    "text = \"Transformers Is so COOL\"\n",
+    "encoded = tokenizer(text)\n",
+    "print(encoded)\n",
+    "\n",
+    "input_ids = encoded[\"input_ids\"]\n",
+    "decoded = tokenizer.decode(input_ids)\n",
+    "print(decoded)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

3장 자연어 처리/예제 3.02 BERT 모델 구조.ipynb

@@ -0,0 +1,50 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e41fc33d",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "from transformers import BertModel\n",
+    "\n",
+    "model = BertModel.from_pretrained(\"google-bert/bert-base-multilingual-uncased\")\n",
+    "\n",
+    "for main_name, main_module in model.named_children():\n",
+    "    print(main_name)\n",
+    "    for sub_name, sub_module in main_module.named_children():\n",
+    "        print(\"└\", sub_name)\n",
+    "        for ssub_name, ssub_module in sub_module.named_children():\n",
+    "            print(\"│  └\", ssub_name)\n",
+    "            for sssub_name, sssub_module in ssub_module.named_children():\n",
+    "                print(\"│  │  └\", sssub_name)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

3장 자연어 처리/예제 3.03 ~ 3.07 텍스트 분류 모델.ipynb

@@ -0,0 +1,169 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e41fc33d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from datasets import load_dataset\n",
+    "from transformers import BertTokenizer, BertForSequenceClassification\n",
+    "\n",
+    "def preprocess_data(example, tokenizer):\n",
+    "    return tokenizer(example[\"document\"], truncation=True)\n",
+    "\n",
+    "model_name = \"google-bert/bert-base-multilingual-uncased\"\n",
+    "tokenizer = BertTokenizer.from_pretrained(model_name)\n",
+    "model = BertForSequenceClassification.from_pretrained(model_name, num_labels=2)\n",
+    "\n",
+    "dataset = load_dataset(\"nsmc\", trust_remote_code=True)\n",
+    "processed_dataset = dataset.map(\n",
+    "    lambda example: preprocess_data(example, tokenizer),\n",
+    "    batched=True,\n",
+    "    remove_columns=[\"id\", \"document\"]\n",
+    ").rename_column(\"label\", \"labels\")\n",
+    "\n",
+    "print(dataset)\n",
+    "print(processed_dataset)\n",
+    "print(dataset[\"train\"][0])\n",
+    "print(processed_dataset[\"train\"][0])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ca996961",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from torch.utils.data import DataLoader\n",
+    "from transformers import DataCollatorWithPadding\n",
+    "\n",
+    "max_length_collator = DataCollatorWithPadding(\n",
+    "    tokenizer=tokenizer,\n",
+    "    padding=\"max_length\"\n",
+    ")\n",
+    "max_length_dataloader = DataLoader(\n",
+    "    processed_dataset[\"train\"],\n",
+    "    collate_fn=max_length_collator,\n",
+    "    batch_size=4,\n",
+    "    shuffle=False\n",
+    ")\n",
+    "max_length_iterator = iter(max_length_dataloader)\n",
+    "max_lnegth_batch = next(max_length_iterator)\n",
+    "print(\"max_length 패딩 입력 id shape :\", max_lnegth_batch[\"input_ids\"].shape)\n",
+    "\n",
+    "longest_collator = DataCollatorWithPadding(\n",
+    "    tokenizer=tokenizer,\n",
+    "    padding=\"longest\"\n",
+    ")\n",
+    "longest_dataloader = DataLoader(\n",
+    "    processed_dataset[\"train\"],\n",
+    "    collate_fn=longest_collator,\n",
+    "    batch_size=4,\n",
+    "    shuffle=False\n",
+    ")\n",
+    "longest_iterator = iter(longest_dataloader)\n",
+    "longest_batch = next(longest_iterator)\n",
+    "print(\"longest 패딩 입력 id shape :\", longest_batch[\"input_ids\"].shape)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f3fe00b8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from transformers import TrainingArguments, Trainer\n",
+    "\n",
+    "training_args = TrainingArguments(\n",
+    "    output_dir=\"text-classification\",\n",
+    "    per_device_train_batch_size=8,\n",
+    "    per_device_eval_batch_size=16,\n",
+    "    learning_rate=5e-5,\n",
+    "    num_train_epochs=1,\n",
+    "    eval_steps=200,\n",
+    "    logging_steps=200,\n",
+    "    seed=42\n",
+    ")\n",
+    "\n",
+    "trainer = Trainer(\n",
+    "    model=model,\n",
+    "    args=training_args,\n",
+    "    data_collator=longest_collator,\n",
+    "    train_dataset=processed_dataset[\"train\"].select(range(10000)),\n",
+    "    eval_dataset=processed_dataset[\"test\"].select(range(100))\n",
+    ")\n",
+    "\n",
+    "trainer.train()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4f2642b5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "\n",
+    "model.eval()\n",
+    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
+    "model.to(device)\n",
+    "\n",
+    "text = \"진짜 재밌었어요. 또 보러 갈거에요\"\n",
+    "inputs = tokenizer(text, return_tensors=\"pt\")\n",
+    "\n",
+    "with torch.no_grad():\n",
+    "    outputs = model(**inputs.to(device))\n",
+    "    print(outputs.logits)\n",
+    "    print(outputs.logits.argmax())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2d2703ab",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import evaluate\n",
+    "\n",
+    "yhat = trainer.predict(processed_dataset[\"test\"])\n",
+    "predictions = yhat.predictions.argmax(axis=1)\n",
+    "references = yhat.label_ids\n",
+    "\n",
+    "metric = evaluate.load(\"accuracy\")\n",
+    "accuracy = metric.compute(predictions=predictions, references=references)\n",
+    "print(accuracy)\n",
+    "\n",
+    "metric = evaluate.load(\"f1\")\n",
+    "f1 = metric.compute(predictions=predictions, references=references)\n",
+    "print(f1)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

3장 자연어 처리/예제 3.08 ~ 3.09 BART 구조.ipynb

@@ -0,0 +1,69 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e41fc33d",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "from transformers import BartTokenizerFast\n",
+    "\n",
+    "tokenizer = BartTokenizerFast.from_pretrained(\"gogamza/kobart-base-v2\")\n",
+    "\n",
+    "text = \"BART는 요약 모델을 학습하기에 적합하다.\"\n",
+    "encoded = tokenizer(text)\n",
+    "print(encoded)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a5ec6a70",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "from transformers import BartForConditionalGeneration\n",
+    "\n",
+    "model = BartForConditionalGeneration.from_pretrained(\"gogamza/kobart-base-v2\")\n",
+    "for main_name, main_module in model.named_children():\n",
+    "    print(main_name)\n",
+    "    for sub_name, sub_module in main_module.named_children():\n",
+    "        print(\"└\", sub_name)\n",
+    "        for ssub_name, ssub_module in sub_module.named_children():\n",
+    "            print(\"│  └\", ssub_name)\n",
+    "            for sssub_name, sssub_module in ssub_module.named_children():\n",
+    "                print(\"│  │  └\", sssub_name)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

3장 자연어 처리/예제 3.10 ~ 3.14 요약문 생성 모델.ipynb

@@ -0,0 +1,222 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e41fc33d",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "from datasets import load_dataset\n",
+    "from transformers import BartTokenizerFast, BartForConditionalGeneration\n",
+    "\n",
+    "def preprocess_data(example, tokenizer):\n",
+    "    return tokenizer(\n",
+    "        example[\"document\"],\n",
+    "        text_target=example[\"summary\"],\n",
+    "        truncation=True\n",
+    "    )\n",
+    "\n",
+    "model_name = \"gogamza/kobart-base-v2\"\n",
+    "tokenizer = BartTokenizerFast.from_pretrained(model_name)\n",
+    "model = BartForConditionalGeneration.from_pretrained(model_name)\n",
+    "\n",
+    "dataset = load_dataset(\"daekeun-ml/naver-news-summarization-ko\")\n",
+    "print(dataset)\n",
+    "\n",
+    "tokenizer.model_max_length = model.config.max_position_embeddings\n",
+    "processed_dataset = dataset.map(\n",
+    "    lambda example: preprocess_data(example, tokenizer),\n",
+    "    batched=True,\n",
+    "    remove_columns=dataset[\"train\"].column_names\n",
+    ")\n",
+    "\n",
+    "sample = processed_dataset[\"train\"][\"labels\"][0]\n",
+    "print(sample)\n",
+    "print(tokenizer.decode(sample))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1ab68856",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "from torch.utils.data import DataLoader\n",
+    "from transformers import DataCollatorForSeq2Seq\n",
+    "\n",
+    "seq2seq_collator = DataCollatorForSeq2Seq(\n",
+    "    tokenizer=tokenizer,\n",
+    "    padding=\"longest\",\n",
+    "    return_tensors=\"pt\"\n",
+    ")\n",
+    "\n",
+    "seq2seq_dataloader = DataLoader(\n",
+    "    processed_dataset[\"train\"],\n",
+    "    collate_fn=seq2seq_collator,\n",
+    "    batch_size=4,\n",
+    "    shuffle=False\n",
+    ")\n",
+    "\n",
+    "seq2seq_iterator = iter(seq2seq_dataloader)\n",
+    "seq2seq_batch = next(seq2seq_iterator)\n",
+    "for key, value in seq2seq_batch.items():\n",
+    "    print(f\"{key} : {value.shape}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0536d7d0",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "from transformers import Seq2SeqTrainingArguments, Seq2SeqTrainer\n",
+    "\n",
+    "training_args = Seq2SeqTrainingArguments(\n",
+    "    output_dir=\"text-summarization\",\n",
+    "    per_device_train_batch_size=8,\n",
+    "    per_device_eval_batch_size=16,\n",
+    "    learning_rate=5e-5,\n",
+    "    num_train_epochs=1,\n",
+    "    eval_steps=200,\n",
+    "    logging_steps=200,\n",
+    "    seed=42\n",
+    ")\n",
+    "\n",
+    "trainer = Seq2SeqTrainer(\n",
+    "    model=model,\n",
+    "    args=training_args,\n",
+    "    data_collator=seq2seq_collator,\n",
+    "    train_dataset=processed_dataset[\"train\"].select(range(10000)),\n",
+    "    eval_dataset=processed_dataset[\"validation\"].select(range(100))\n",
+    ")\n",
+    "\n",
+    "trainer.train()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "45bd400b",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "\n",
+    "model.eval()\n",
+    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
+    "model.to(device)\n",
+    "\n",
+    "sample = dataset[\"test\"][0]\n",
+    "document = sample[\"document\"]\n",
+    "inputs = tokenizer(document, return_tensors=\"pt\").to(device)\n",
+    "\n",
+    "with torch.no_grad():\n",
+    "    outputs = model.generate(\n",
+    "        **inputs,\n",
+    "        max_length=256,\n",
+    "        num_beams=4,\n",
+    "        no_repeat_ngram_size=2,\n",
+    "        early_stopping=True\n",
+    "    )\n",
+    "print(\"원문 :\", document)\n",
+    "print(\"정답 요약문 :\", sample[\"summary\"])\n",
+    "print(\"생성 요약문 :\", tokenizer.decode(outputs[0], skip_special_tokens=True))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d4e44df8",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "!pip install rouge_score"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "727fabd2",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import evaluate\n",
+    "\n",
+    "test_loader = DataLoader(\n",
+    "    processed_dataset[\"test\"].select(range(100)),\n",
+    "    collate_fn=seq2seq_collator,\n",
+    "    batch_size=4,\n",
+    "    shuffle=False\n",
+    ")\n",
+    "\n",
+    "generated_summaries = []\n",
+    "true_summaries = dataset[\"test\"].select(range(100))[\"summary\"]\n",
+    "\n",
+    "with torch.no_grad():\n",
+    "    for batch in test_loader:\n",
+    "        batch = batch.to(device)\n",
+    "        output = model.generate(\n",
+    "            **batch,\n",
+    "            max_length=1026,\n",
+    "            num_beams=4,\n",
+    "            no_repeat_ngram_size=2,\n",
+    "            early_stopping=True\n",
+    "        )\n",
+    "        batch_summaries = tokenizer.batch_decode(output, skip_special_tokens=True)\n",
+    "        generated_summaries.extend(batch_summaries)\n",
+    "\n",
+    "metric = evaluate.load(\"rouge\")\n",
+    "rouge_scores = metric.compute(predictions=generated_summaries, references=true_summaries)\n",
+    "print(rouge_scores)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

3장 자연어 처리/예제 3.15 ~ 3.18 추출 질의 응답 모델.ipynb

@@ -0,0 +1,177 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e4ce77ca",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "from datasets import load_dataset\n",
+    "from transformers import RobertaTokenizerFast, RobertaForQuestionAnswering\n",
+    "\n",
+    "def preprocess_data(example, tokenizer):\n",
+    "    tokenized = tokenizer(\n",
+    "        example[\"question\"],\n",
+    "        example[\"context\"],\n",
+    "        truncation=\"only_second\",\n",
+    "        return_offsets_mapping=True\n",
+    "    )\n",
+    "    start_index = example[\"answers\"][\"answer_start\"][0]\n",
+    "    answer_text = example[\"answers\"][\"text\"][0]\n",
+    "    answer_tokens = tokenizer.encode(answer_text, add_special_tokens=False)\n",
+    "    answer_tokens_length = len(answer_tokens)\n",
+    "\n",
+    "    start_context_tokens_index = tokenized[\"input_ids\"].index(tokenizer.sep_token_id)\n",
+    "    context_offset_mapping = tokenized[\"offset_mapping\"][start_context_tokens_index:]\n",
+    "    tokenized[\"start_positions\"] = len(tokenized[\"input_ids\"])\n",
+    "    tokenized[\"end_positions\"] = len(tokenized[\"input_ids\"])\n",
+    "    \n",
+    "    for i, (start_offset, end_offset) in enumerate(context_offset_mapping):\n",
+    "        if start_offset >= start_index:\n",
+    "            tokenized[\"start_positions\"] = start_context_tokens_index + i\n",
+    "            tokenized[\"end_positions\"] = tokenized[\"start_positions\"] + answer_tokens_length\n",
+    "            break\n",
+    "\n",
+    "    return tokenized\n",
+    "\n",
+    "model_name = \"klue/roberta-base\"\n",
+    "tokenizer = RobertaTokenizerFast.from_pretrained(model_name)\n",
+    "model = RobertaForQuestionAnswering.from_pretrained(model_name)\n",
+    "\n",
+    "dataset = load_dataset(\"klue\", \"mrc\")\n",
+    "processed_dataset = dataset.filter(lambda x: not x[\"is_impossible\"])\n",
+    "processed_dataset = processed_dataset.map(\n",
+    "    lambda example: preprocess_data(example, tokenizer), batched=False\n",
+    ")\n",
+    "processed_dataset = processed_dataset.filter(\n",
+    "    lambda x: x[\"start_positions\"] < tokenizer.model_max_length\n",
+    ")\n",
+    "processed_dataset = processed_dataset.filter(\n",
+    "    lambda x: x[\"end_positions\"] < tokenizer.model_max_length\n",
+    ")\n",
+    "print(dataset)\n",
+    "print(processed_dataset)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ce30aba3",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "from transformers import DataCollatorWithPadding, TrainingArguments, Trainer\n",
+    "\n",
+    "collator = DataCollatorWithPadding(tokenizer, padding=\"longest\")\n",
+    "\n",
+    "training_arguments = TrainingArguments(\n",
+    "    output_dir=\"question-answering\",\n",
+    "    per_device_train_batch_size=8,\n",
+    "    per_device_eval_batch_size=16,\n",
+    "    learning_rate=5e-5,\n",
+    "    num_train_epochs=1,\n",
+    "    eval_steps=250,\n",
+    "    logging_steps=250,\n",
+    "    seed=42\n",
+    ")\n",
+    "\n",
+    "trainer = Trainer(\n",
+    "    model=model,\n",
+    "    args=training_arguments,\n",
+    "    data_collator=collator,\n",
+    "    train_dataset=processed_dataset[\"train\"].select(range(10000)),\n",
+    "    eval_dataset=processed_dataset[\"validation\"].select(range(100))\n",
+    ")\n",
+    "\n",
+    "trainer.train()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "51a813f0",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "\n",
+    "model.eval()\n",
+    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
+    "model.to(device)\n",
+    "\n",
+    "question = \"대한민국의 수도는 어디인가요?\"\n",
+    "context = \"서울은 대한민국의 수도다.\"\n",
+    "inputs = tokenizer(question, context, return_tensors=\"pt\").to(device)\n",
+    "\n",
+    "with torch.no_grad():\n",
+    "    outputs = model(**inputs)\n",
+    "\n",
+    "start_index = outputs[\"start_logits\"].argmax(dim=-1).item()\n",
+    "end_index = outputs[\"end_logits\"].argmax(dim=-1).item()\n",
+    "predicted_ids = inputs[\"input_ids\"][0][start_index : end_index]\n",
+    "predicted_text = tokenizer.decode(predicted_ids)\n",
+    "print(predicted_text)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c5898add",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "from evaluate import evaluator\n",
+    "\n",
+    "metric = evaluator(\"question-answering\")\n",
+    "results = metric.compute(\n",
+    "    model,\n",
+    "    tokenizer=tokenizer,\n",
+    "    data=processed_dataset[\"validation\"].select(range(100)),\n",
+    "    id_column=\"guid\",\n",
+    "    question_column=\"question\",\n",
+    "    context_column=\"context\",\n",
+    "    label_column=\"answers\"\n",
+    ")\n",
+    "print(results)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

3장 자연어 처리/예제 3.19 ~ 3.22 기계 번역 모델 copy.ipynb

@@ -0,0 +1,169 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from datasets import load_dataset\n",
+    "from transformers import T5TokenizerFast, T5ForConditionalGeneration\n",
+    "\n",
+    "def preprocess_data(example, tokenizer):\n",
+    "    translation = example[\"translation\"]\n",
+    "    translation_source = [\"en: \" + instance[\"en\"] for instance in translation]\n",
+    "    translation_target = [\"ko: \" + instance[\"ko\"] for instance in translation]\n",
+    "    tokenized = tokenizer(\n",
+    "        translation_source,\n",
+    "        text_target=translation_target,\n",
+    "        truncation=True\n",
+    "    )\n",
+    "    return tokenized\n",
+    "\n",
+    "model_name = \"KETI-AIR/long-ke-t5-small\"\n",
+    "tokenizer = T5TokenizerFast.from_pretrained(model_name)\n",
+    "model = T5ForConditionalGeneration.from_pretrained(\"KETI-AIR/long-ke-t5-small\")\n",
+    "\n",
+    "dataset = load_dataset(\"Helsinki-NLP/opus-100\", \"en-ko\")\n",
+    "processed_dataset = dataset.map(\n",
+    "    lambda example: preprocess_data(example, tokenizer),\n",
+    "    batched=True,\n",
+    "    remove_columns=dataset[\"train\"].column_names\n",
+    ")\n",
+    "\n",
+    "sample = processed_dataset[\"test\"][0]\n",
+    "print(sample)\n",
+    "print(\"변환된 출발 언어 :\", tokenizer.decode(sample[\"input_ids\"]))\n",
+    "print(\"변환된 도착 언어 :\", tokenizer.decode(sample[\"labels\"]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c901d8ae",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from transformers import DataCollatorForSeq2Seq\n",
+    "from transformers import Seq2SeqTrainingArguments, Seq2SeqTrainer\n",
+    "\n",
+    "seq2seq_collator = DataCollatorForSeq2Seq(\n",
+    "    tokenizer=tokenizer,\n",
+    "    padding=\"longest\",\n",
+    "    return_tensors=\"pt\"\n",
+    ")\n",
+    "\n",
+    "training_arguments = Seq2SeqTrainingArguments(\n",
+    "    output_dir=\"t5-translation\",\n",
+    "    per_device_train_batch_size=8,\n",
+    "    per_device_eval_batch_size=16,\n",
+    "    learning_rate=5e-5,\n",
+    "    num_train_epochs=1,\n",
+    "    eval_steps=2500,\n",
+    "    logging_steps=2500,\n",
+    "    seed=42\n",
+    ")\n",
+    "\n",
+    "trainer = Seq2SeqTrainer(\n",
+    "    model=model,\n",
+    "    args=training_arguments,\n",
+    "    data_collator=seq2seq_collator,\n",
+    "    train_dataset=processed_dataset[\"train\"].select(range(100000)),\n",
+    "    eval_dataset=processed_dataset[\"validation\"].select(range(1000))\n",
+    ")\n",
+    "\n",
+    "trainer.train()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5e4c93c5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "\n",
+    "model.eval()\n",
+    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
+    "model.to(device)\n",
+    "\n",
+    "data = \"en: It's always great to acquire new knowledge.\"\n",
+    "inputs = tokenizer(data, return_tensors=\"pt\").to(device)\n",
+    "\n",
+    "with torch.no_grad():\n",
+    "    outputs = model.generate(\n",
+    "        **inputs,\n",
+    "        max_length=512,\n",
+    "        num_beams=4,\n",
+    "        no_repeat_ngram_size=2,\n",
+    "        early_stopping=True\n",
+    "    )\n",
+    "print(tokenizer.decode(outputs[0], skip_special_tokens=True))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a28e8515",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import evaluate\n",
+    "from torch.utils.data import DataLoader\n",
+    "\n",
+    "dataloader = DataLoader(\n",
+    "    processed_dataset[\"test\"].select(range(100)),\n",
+    "    collate_fn=seq2seq_collator,\n",
+    "    batch_size=4,\n",
+    "    shuffle=False\n",
+    ")\n",
+    "\n",
+    "generated_translated = []\n",
+    "true_translated_ids = processed_dataset[\"test\"].select(range(100))[\"labels\"]\n",
+    "true_translated = tokenizer.batch_decode(true_translated_ids, skip_special_tokens=True)\n",
+    "\n",
+    "with torch.no_grad():\n",
+    "    for batch in dataloader:\n",
+    "        batch = batch.to(device)\n",
+    "        output = model.generate(\n",
+    "            **batch,\n",
+    "            max_length=1026,\n",
+    "            num_beams=4,\n",
+    "            no_repeat_ngram_size=2,\n",
+    "            early_stopping=True\n",
+    "        )\n",
+    "        batch_translated = tokenizer.batch_decode(output, skip_special_tokens=True)\n",
+    "        generated_translated.extend(batch_translated)\n",
+    "\n",
+    "metric = evaluate.load(\"bleu\")\n",
+    "bleu_scores = metric.compute(\n",
+    "    predictions=generated_translated,\n",
+    "    references=true_translated\n",
+    ")\n",
+    "print(bleu_scores)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

3장 자연어 처리/예제 3.23 ~ 3.26 LLaMA-3.1 실습.ipynb

@@ -0,0 +1,175 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7a8847de",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "from transformers import BitsAndBytesConfig\n",
+    "from transformers import AutoTokenizer, AutoModelForCausalLM\n",
+    "\n",
+    "quantization_config = BitsAndBytesConfig(\n",
+    "    load_in_4bit=True,\n",
+    "    bnb_4bit_quant_type=\"nf4\",\n",
+    "    bnb_4bit_compute_dtype=torch.float16,\n",
+    "    bnb_4bit_use_double_quant=False\n",
+    ")\n",
+    "\n",
+    "token = \"hf_###...\" # 토큰 입력\n",
+    "model_name = \"meta-llama/Meta-Llama-3.1-8B-Instruct\"\n",
+    "\n",
+    "tokenizer = AutoTokenizer.from_pretrained(\n",
+    "    model_name,\n",
+    "    trust_remote_code=True,\n",
+    "    token=token\n",
+    ")\n",
+    "model = AutoModelForCausalLM.from_pretrained(\n",
+    "    model_name,\n",
+    "    quantization_config=quantization_config,\n",
+    "    device_map={\"\": 0},\n",
+    "    token=token\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "949ec23a",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "model.eval()\n",
+    "\n",
+    "messages = [\n",
+    "    {\"role\": \"user\", \"content\": \"안녕하세요.\"}\n",
+    "]\n",
+    "\n",
+    "input_ids = tokenizer.apply_chat_template(\n",
+    "    messages,\n",
+    "    add_generation_prompt=True,\n",
+    "    return_tensors=\"pt\"\n",
+    ").to(model.device)\n",
+    "\n",
+    "with torch.no_grad():\n",
+    "    outputs = model.generate(\n",
+    "        input_ids,\n",
+    "        max_new_tokens=256,\n",
+    "        do_sample=True,\n",
+    "        temperature=0.7,\n",
+    "        top_p=0.9\n",
+    "    )\n",
+    "\n",
+    "response = outputs[0][input_ids.shape[-1]:]\n",
+    "print(tokenizer.decode(response, skip_special_tokens=True))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "55a86b07",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "model.eval()\n",
+    "\n",
+    "messages = [\n",
+    "    {\"role\": \"system\", \"content\": \"저는 위키북스의 챗봇 위키봇입니다.\"},\n",
+    "    {\"role\": \"user\", \"content\": \"안녕하세요, 당신은 누구인가요?\"}\n",
+    "]\n",
+    "\n",
+    "input_ids = tokenizer.apply_chat_template(\n",
+    "    messages,\n",
+    "    add_generation_prompt=True,\n",
+    "    return_tensors=\"pt\"\n",
+    ").to(model.device)\n",
+    "\n",
+    "with torch.no_grad():\n",
+    "    outputs = model.generate(\n",
+    "        input_ids,\n",
+    "        max_new_tokens=256,\n",
+    "        do_sample=True,\n",
+    "        temperature=0.7,\n",
+    "        top_p=0.9\n",
+    "    )\n",
+    "\n",
+    "response = outputs[0][input_ids.shape[-1]:]\n",
+    "print(tokenizer.decode(response, skip_special_tokens=True))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9cc7c318",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "model.eval()\n",
+    "\n",
+    "messages = [\n",
+    "    {\"role\": \"system\", \"content\": \"저는 위키북스의 챗봇 위키봇입니다.\"},\n",
+    "    {\"role\": \"user\", \"content\": \"안녕하세요, 제 이름은 홍길동입니다.\"},\n",
+    "    {\"role\": \"assistant\", \"content\": \"안녕하세요! 나는 위키북스의 챗봇, 위키봇입니다. 위키북스에서 다양한 지식을 공유하고 도울 목적으로 개발된 챗봇입니다. 제가 도와드릴 수 있는 다양한 주제와 질문에 대해 질문해 주세요!\"},\n",
+    "    {\"role\": \"user\", \"content\": \"제 이름을 알고 있나요?\"}\n",
+    "]\n",
+    "\n",
+    "input_ids = tokenizer.apply_chat_template(\n",
+    "    messages,\n",
+    "    add_generation_prompt=True,\n",
+    "    return_tensors=\"pt\"\n",
+    ").to(model.device)\n",
+    "\n",
+    "with torch.no_grad():\n",
+    "    outputs = model.generate(\n",
+    "        input_ids,\n",
+    "        max_new_tokens=256,\n",
+    "        do_sample=True,\n",
+    "        temperature=0.7,\n",
+    "        top_p=0.9\n",
+    "    )\n",
+    "\n",
+    "response = outputs[0][input_ids.shape[-1]:]\n",
+    "print(tokenizer.decode(response, skip_special_tokens=True))"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

3장 자연어 처리/예제 3.27 ~ 3.30 LLaMA-3.1 미세 조정.ipynb

@@ -0,0 +1,170 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e132c346",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "from datasets import load_dataset\n",
+    "from transformers import BitsAndBytesConfig\n",
+    "from transformers import AutoTokenizer, AutoModelForCausalLM\n",
+    "\n",
+    "dataset = load_dataset(\"s076923/llama3-wikibook-ko\")\n",
+    "\n",
+    "quantization_config = BitsAndBytesConfig(\n",
+    "    load_in_4bit=True,\n",
+    "    bnb_4bit_quant_type=\"nf4\",\n",
+    "    bnb_4bit_compute_dtype=torch.float16,\n",
+    "    bnb_4bit_use_double_quant=False\n",
+    ")\n",
+    "\n",
+    "token = \"hf_###...\" # 토큰 입력\n",
+    "model_name = \"meta-llama/Meta-Llama-3.1-8B-Instruct\"\n",
+    "\n",
+    "tokenizer = AutoTokenizer.from_pretrained(\n",
+    "    model_name,\n",
+    "    trust_remote_code=True,\n",
+    "    token=token\n",
+    ")\n",
+    "model = AutoModelForCausalLM.from_pretrained(\n",
+    "    model_name,\n",
+    "    quantization_config=quantization_config,\n",
+    "    device_map={\"\": 0},\n",
+    "    token=token\n",
+    ")\n",
+    "\n",
+    "tokenizer.pad_token = tokenizer.eos_token\n",
+    "model.config.use_cache = False\n",
+    "\n",
+    "print(dataset)\n",
+    "print(dataset[\"train\"][\"text\"][7])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "92732a20",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "from peft import LoraConfig\n",
+    "\n",
+    "peft_config = LoraConfig(\n",
+    "    r=128,\n",
+    "    lora_alpha=4,\n",
+    "    lora_dropout=0.1,\n",
+    "    task_type=\"CAUSAL_LM\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8bd9a04f",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "from transformers import TrainingArguments\n",
+    "from trl import SFTTrainer\n",
+    "\n",
+    "training_args = TrainingArguments(\n",
+    "    output_dir=\"LLaMa-3.1\",\n",
+    "    per_device_train_batch_size=1,\n",
+    "    gradient_accumulation_steps=5,\n",
+    "    learning_rate=2e-4,\n",
+    "    max_steps=500,\n",
+    "    warmup_steps=100,\n",
+    "    logging_steps=100,\n",
+    "    fp16=True,\n",
+    "    optim=\"paged_adamw_8bit\",\n",
+    "    seed=42\n",
+    ")\n",
+    "\n",
+    "trainer = SFTTrainer(\n",
+    "    model=model,\n",
+    "    tokenizer=tokenizer,\n",
+    "    args=training_args,\n",
+    "    peft_config=peft_config,\n",
+    "    train_dataset=dataset[\"train\"],\n",
+    "    dataset_text_field=\"text\",\n",
+    "    max_seq_length=64\n",
+    ")\n",
+    "\n",
+    "trainer.train()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1a2d070b",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "model.eval()\n",
+    "\n",
+    "messages = [\n",
+    "    {\"role\": \"user\", \"content\": \"위키북스 대표 저자는 누구예요?\"},\n",
+    "]\n",
+    "\n",
+    "input_ids = tokenizer.apply_chat_template(\n",
+    "    messages,\n",
+    "    add_generation_prompt=True,\n",
+    "    return_tensors=\"pt\"\n",
+    ").to(model.device)\n",
+    "\n",
+    "with torch.no_grad():\n",
+    "    outputs = model.generate(\n",
+    "        input_ids,\n",
+    "        max_new_tokens=64,\n",
+    "        do_sample=True,\n",
+    "        temperature=0.2,\n",
+    "        top_p=0.95,\n",
+    "        no_repeat_ngram_size=2\n",
+    "    )\n",
+    "\n",
+    "response = outputs[0][input_ids.shape[-1]:]\n",
+    "print(tokenizer.decode(response, skip_special_tokens=True))"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

4장 컴퓨터 비전/예제 4.01 ~ 4.03 제로샷 이미지 분류.ipynb

@@ -0,0 +1,124 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e41fc33d",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "from datasets import load_dataset\n",
+    "from transformers import CLIPProcessor, CLIPModel\n",
+    "\n",
+    "model_name = \"openai/clip-vit-base-patch32\"\n",
+    "processor = CLIPProcessor.from_pretrained(model_name)\n",
+    "model = CLIPModel.from_pretrained(model_name)\n",
+    "\n",
+    "dataset = load_dataset(\"sasha/dog-food\")\n",
+    "images = dataset[\"test\"][\"image\"][:2]\n",
+    "labels = [\"dog\", \"food\"]\n",
+    "inputs = processor(images=images, text=labels, return_tensors=\"pt\") # padding=True\n",
+    "\n",
+    "print(\"input_ids :\", inputs[\"input_ids\"])\n",
+    "print(\"attention_mask :\", inputs[\"attention_mask\"])\n",
+    "print(\"pixel_values :\", inputs[\"pixel_values\"])\n",
+    "print(\"image_shape :\", inputs[\"pixel_values\"].shape)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ac651f7b",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "\n",
+    "model.eval()\n",
+    "with torch.no_grad():\n",
+    "    outputs = model(**inputs)\n",
+    "    logits_per_image = outputs.logits_per_image\n",
+    "    probs = logits_per_image.softmax(dim=1)\n",
+    "    print(\"outputs :\", outputs.keys())\n",
+    "    print(\"logits_per_image :\", logits_per_image)\n",
+    "    print(\"probs :\", probs)\n",
+    "\n",
+    "for idx, prob in enumerate(probs):\n",
+    "    print(f\"- Image #{idx}\")\n",
+    "    for label, p in zip(labels, prob):\n",
+    "        print(f\"{label} : {p:.4f}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0d98c946",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import evaluate\n",
+    "from torch.utils.data import DataLoader\n",
+    "\n",
+    "test_dataloader = DataLoader(\n",
+    "    dataset[\"test\"],\n",
+    "    batch_size=8,\n",
+    "    collate_fn=lambda batch: (\n",
+    "        [item[\"image\"] for item in batch],\n",
+    "        [item[\"label\"] for item in batch],\n",
+    "    ),\n",
+    ")\n",
+    "\n",
+    "metric = evaluate.load(\"accuracy\")\n",
+    "predictions, references = [], []\n",
+    "labels_names = dataset[\"test\"].features[\"label\"].names\n",
+    "\n",
+    "model.eval()\n",
+    "with torch.no_grad():\n",
+    "    for images, labels in test_dataloader:\n",
+    "        inputs = processor(images=images, text=labels_names, return_tensors=\"pt\")\n",
+    "        outputs = model(**inputs)\n",
+    "        probs = outputs.logits_per_image.softmax(dim=1)\n",
+    "\n",
+    "        predictions += probs.argmax(dim=1).cpu().tolist()\n",
+    "        references += labels\n",
+    "\n",
+    "results = metric.compute(predictions=predictions, references=references)\n",
+    "print(f\"클래스 목록 : {labels_names}\")\n",
+    "print(f\"정확도 : {results['accuracy']*100 :.2f}%\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

4장 컴퓨터 비전/예제 4.04 ~ 4.11 제로샷 객체 검출.ipynb

@@ -0,0 +1,290 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d3eaffd0",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import io\n",
+    "from PIL import Image\n",
+    "from datasets import load_dataset\n",
+    "from transformers import Owlv2Processor, Owlv2ForObjectDetection\n",
+    "\n",
+    "model_name = \"google/owlv2-base-patch16\"\n",
+    "processor = Owlv2Processor.from_pretrained(model_name)\n",
+    "model = Owlv2ForObjectDetection.from_pretrained(model_name)\n",
+    "\n",
+    "dataset = load_dataset(\"Francesco/animals-ij5d2\")\n",
+    "print(dataset)\n",
+    "print(dataset[\"test\"][0])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1f322644",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "images = dataset[\"test\"][\"image\"][:2]\n",
+    "categories = dataset[\"test\"].features[\"objects\"].feature[\"category\"].names\n",
+    "labels = [categories] * len(images)\n",
+    "inputs = processor(text=labels, images=images, return_tensors=\"pt\", padding=True)\n",
+    "\n",
+    "print(images)\n",
+    "print(labels)\n",
+    "print(\"input_ids :\", inputs[\"input_ids\"])\n",
+    "print(\"attention_mask :\", inputs[\"attention_mask\"])\n",
+    "print(\"pixel_values :\", inputs[\"pixel_values\"])\n",
+    "print(\"image_shape :\", inputs[\"pixel_values\"].shape)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fdc753ca",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "\n",
+    "model.eval()\n",
+    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
+    "model.to(device)\n",
+    "\n",
+    "with torch.no_grad():\n",
+    "    outputs = model(**inputs.to(device))\n",
+    "    \n",
+    "print(outputs.keys())\n",
+    "print(\"logits :\", outputs.logits.shape)\n",
+    "print(\"objectness_logits :\", outputs.objectness_logits.shape)\n",
+    "print(\"pred_boxes :\", outputs.pred_boxes.shape)\n",
+    "print(\"class_embeds :\", outputs.class_embeds.shape)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "24a01f43",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "shape = [dataset[\"test\"][:2][\"width\"], dataset[\"test\"][:2][\"height\"]]\n",
+    "target_sizes = list(map(list, zip(*shape)))\n",
+    "detections = processor.post_process_object_detection(\n",
+    "    outputs=outputs, threshold=0.5, target_sizes=target_sizes\n",
+    ")\n",
+    "\n",
+    "print(target_sizes)\n",
+    "print(detections)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ab07c0bd",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "from PIL import ImageDraw, ImageFont\n",
+    "\n",
+    "for idx, (image, detect) in enumerate(zip(images, detections)):\n",
+    "    im = image.copy()\n",
+    "    draw = ImageDraw.Draw(im)\n",
+    "    font = ImageFont.truetype(\"arial.ttf\", 36)\n",
+    "\n",
+    "    for box, score, label in zip(detect[\"boxes\"], detect[\"scores\"], detect[\"labels\"]):\n",
+    "        box = [round(i, 2) for i in box.tolist()]\n",
+    "        draw.rectangle(box, outline=\"red\", width=3)\n",
+    "        \n",
+    "        label_text = f\"{labels[idx][label]}: {round(score.item(), 3)}\"\n",
+    "        draw.text((box[0], box[1]), label_text, fill=\"red\", font=font)\n",
+    "\n",
+    "    plt.imshow(im)\n",
+    "    plt.axis(\"off\")\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9d9c46ef",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "!pip install pycocotools"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "968261fa",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "def get_coco_annotations(dataset):\n",
+    "    annotations = []\n",
+    "    for data in dataset:\n",
+    "        image_id = int(data[\"image_id\"])\n",
+    "        objects = data[\"objects\"]\n",
+    "        for idx in range(len(objects[\"id\"])):\n",
+    "            annotations.append(\n",
+    "                {\n",
+    "                    \"image_id\": image_id,\n",
+    "                    \"category_id\": int(objects[\"category\"][idx]),\n",
+    "                    \"bbox\": [float(coord) for coord in objects[\"bbox\"][idx]],\n",
+    "                    \"area\": float(objects[\"area\"][idx]),\n",
+    "                    \"id\": int(objects[\"id\"][idx]),\n",
+    "                    \"iscrowd\": 0\n",
+    "                }\n",
+    "            )\n",
+    "    return annotations\n",
+    "\n",
+    "coco_annotations = get_coco_annotations(dataset[\"test\"])\n",
+    "coco_annotation_format = {\n",
+    "    \"annotations\": coco_annotations,\n",
+    "    \"images\": [{\"id\": int(data[\"image_id\"])} for data in dataset[\"test\"]],\n",
+    "    \"categories\": [{\"id\": i, \"name\": name} for i, name in enumerate(categories)]\n",
+    "}\n",
+    "print(len(coco_annotations))\n",
+    "print(coco_annotation_format[\"annotations\"][0])\n",
+    "print(coco_annotation_format[\"images\"][0])\n",
+    "print(coco_annotation_format[\"categories\"][0])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "84ab7984",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "from torch.utils.data import DataLoader\n",
+    "\n",
+    "dataloader = DataLoader(\n",
+    "    dataset[\"test\"],\n",
+    "    batch_size=2,\n",
+    "    collate_fn=lambda batch: (\n",
+    "        [item[\"image\"] for item in batch],\n",
+    "        [list(item[\"image\"].size) for item in batch],\n",
+    "        [item[\"image_id\"] for item in batch],\n",
+    "        [item[\"objects\"] for item in batch]\n",
+    "    )\n",
+    ")\n",
+    "\n",
+    "predictions = []\n",
+    "model.eval()\n",
+    "with torch.no_grad():\n",
+    "    for images, target_sizes, image_ids, objects in dataloader:\n",
+    "        input_labels = [categories] * len(images)\n",
+    "        inputs = processor(images=images, text=input_labels, return_tensors=\"pt\")\n",
+    "        outputs = model(**inputs.to(device))\n",
+    "        detections = processor.post_process_object_detection(\n",
+    "            outputs=outputs, threshold=0.3, target_sizes=target_sizes\n",
+    "        )\n",
+    "\n",
+    "        for batch_idx, detection in enumerate(detections):\n",
+    "            category_ids = detection[\"labels\"].cpu().numpy().tolist()\n",
+    "            scores = detection[\"scores\"].cpu().numpy().tolist()\n",
+    "            boxes = detection[\"boxes\"].cpu().numpy()\n",
+    "\n",
+    "            boxes[:, 2:4] -= boxes[:, :2]\n",
+    "            boxes = boxes.tolist()\n",
+    "\n",
+    "            for obj_idx, box in enumerate(boxes):\n",
+    "                prediction = {\n",
+    "                    \"image_id\": image_ids[batch_idx],\n",
+    "                    \"category_id\": category_ids[obj_idx],\n",
+    "                    \"bbox\": box,\n",
+    "                    \"score\": scores[obj_idx]\n",
+    "                }\n",
+    "                predictions.append(prediction)\n",
+    "\n",
+    "print(len(predictions))\n",
+    "print(predictions[0])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "dcda78ac",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "from pycocotools.coco import COCO\n",
+    "from pycocotools.cocoeval import COCOeval\n",
+    "\n",
+    "coco_gt = COCO()\n",
+    "coco_gt.dataset = coco_annotation_format\n",
+    "coco_gt.createIndex()\n",
+    "\n",
+    "coco_dt = coco_gt.loadRes(predictions)\n",
+    "\n",
+    "coco_eval = COCOeval(coco_gt, coco_dt, \"bbox\")\n",
+    "coco_eval.evaluate()\n",
+    "coco_eval.accumulate()\n",
+    "coco_eval.summarize()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

4장 컴퓨터 비전/예제 4.12 ~ 4.17 이미지 세그먼테이션.ipynb

@@ -0,0 +1,314 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9d9c46ef",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import io\n",
+    "from PIL import Image\n",
+    "from datasets import load_dataset\n",
+    "from transformers import SamProcessor, SamModel\n",
+    "\n",
+    "def filter_category(data):\n",
+    "    # 16 = dog\n",
+    "    # 23 = giraffe\n",
+    "    return 16 in data[\"objects\"][\"category\"] or 23 in data[\"objects\"][\"category\"]\n",
+    "\n",
+    "def convert_image(data):\n",
+    "    byte = io.BytesIO(data[\"image\"][\"bytes\"])\n",
+    "    img = Image.open(byte)\n",
+    "    return {\"img\": img}\n",
+    "\n",
+    "model_name = \"facebook/sam-vit-base\"\n",
+    "processor = SamProcessor.from_pretrained(model_name) \n",
+    "model = SamModel.from_pretrained(model_name)\n",
+    "\n",
+    "dataset = load_dataset(\"s076923/coco-val\")\n",
+    "filtered_dataset = dataset[\"validation\"].filter(filter_category)\n",
+    "converted_dataset = filtered_dataset.map(convert_image, remove_columns=[\"image\"])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4eece5f7",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "from matplotlib import pyplot as plt\n",
+    "\n",
+    "\n",
+    "def show_point_box(image, input_points, input_labels, input_boxes=None, marker_size=375):\n",
+    "    plt.figure(figsize=(10, 10))\n",
+    "    plt.imshow(image)\n",
+    "    ax = plt.gca()\n",
+    "    \n",
+    "    input_points = np.array(input_points)\n",
+    "    input_labels = np.array(input_labels)\n",
+    "\n",
+    "    pos_points = input_points[input_labels[0] == 1]\n",
+    "    neg_points = input_points[input_labels[0] == 0]\n",
+    "    \n",
+    "    ax.scatter(\n",
+    "        pos_points[:, 0],\n",
+    "        pos_points[:, 1],\n",
+    "        color=\"green\",\n",
+    "        marker=\"*\",\n",
+    "        s=marker_size,\n",
+    "        edgecolor=\"white\",\n",
+    "        linewidth=1.25\n",
+    "    )\n",
+    "    ax.scatter(\n",
+    "        neg_points[:, 0],\n",
+    "        neg_points[:, 1],\n",
+    "        color=\"red\",\n",
+    "        marker=\"*\",\n",
+    "        s=marker_size,\n",
+    "        edgecolor=\"white\",\n",
+    "        linewidth=1.25\n",
+    "    )\n",
+    "\n",
+    "    if input_boxes is not None:\n",
+    "        for box in input_boxes:\n",
+    "            x0, y0 = box[0], box[1]\n",
+    "            w, h = box[2] - box[0], box[3] - box[1]\n",
+    "            ax.add_patch(\n",
+    "                plt.Rectangle(\n",
+    "                    (x0, y0), w, h, edgecolor=\"green\", facecolor=(0, 0, 0, 0), lw=2\n",
+    "                )\n",
+    "            )\n",
+    "\n",
+    "    plt.axis(\"on\")\n",
+    "    plt.show()\n",
+    "\n",
+    "\n",
+    "image = converted_dataset[0][\"img\"]\n",
+    "input_points = [[[250, 200]]]\n",
+    "input_labels = [[[1]]]\n",
+    "\n",
+    "show_point_box(image, input_points[0], input_labels[0])\n",
+    "inputs = processor(\n",
+    "    image, input_points=input_points, input_labels=input_labels, return_tensors=\"pt\"\n",
+    ")\n",
+    "\n",
+    "print(\"input_points shape :\", inputs[\"input_points\"].shape)\n",
+    "print(\"input_points :\", inputs[\"input_points\"])\n",
+    "print(\"input_labels shape :\", inputs[\"input_labels\"].shape)\n",
+    "print(\"input_labels :\", inputs[\"input_labels\"])\n",
+    "print(\"pixel_values shape :\", inputs[\"pixel_values\"].shape)\n",
+    "print(\"pixel_values :\", inputs[\"pixel_values\"])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5116671c",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "\n",
+    "\n",
+    "def show_mask(mask, ax, random_color=False):\n",
+    "    if random_color:\n",
+    "        color = np.concatenate([np.random.random(3), np.array([0.6])], axis=0)\n",
+    "    else:\n",
+    "        color = np.array([30 / 255, 144 / 255, 255 / 255, 0.6])\n",
+    "    h, w = mask.shape[-2:]\n",
+    "    mask_image = mask.reshape(h, w, 1) * color.reshape(1, 1, -1)\n",
+    "    ax.imshow(mask_image)\n",
+    "\n",
+    "\n",
+    "def show_masks_on_image(raw_image, masks, scores):\n",
+    "    if len(masks.shape) == 4:\n",
+    "        masks = masks.squeeze()\n",
+    "    if scores.shape[0] == 1:\n",
+    "        scores = scores.squeeze()\n",
+    "\n",
+    "    nb_predictions = scores.shape[-1]\n",
+    "    fig, axes = plt.subplots(1, nb_predictions, figsize=(30, 15))\n",
+    "\n",
+    "    for i, (mask, score) in enumerate(zip(masks, scores)):\n",
+    "        mask = mask.cpu().detach()\n",
+    "        axes[i].imshow(np.array(raw_image))\n",
+    "        show_mask(mask, axes[i])\n",
+    "        axes[i].title.set_text(f\"Mask {i+1}, Score: {score.item():.3f}\")\n",
+    "        axes[i].axis(\"off\")\n",
+    "    plt.show()\n",
+    "\n",
+    "\n",
+    "model.eval()\n",
+    "with torch.no_grad():\n",
+    "    outputs = model(**inputs)\n",
+    "\n",
+    "masks = processor.image_processor.post_process_masks(\n",
+    "    outputs.pred_masks.cpu(),\n",
+    "    inputs[\"original_sizes\"].cpu(),\n",
+    "    inputs[\"reshaped_input_sizes\"].cpu(),\n",
+    ")\n",
+    "\n",
+    "show_masks_on_image(image, masks[0], outputs.iou_scores)\n",
+    "print(\"iou_scores shape :\", outputs.iou_scores.shape)\n",
+    "print(\"iou_scores :\", outputs.iou_scores)\n",
+    "print(\"pred_masks shape :\", outputs.pred_masks.shape)\n",
+    "print(\"pred_masks :\", outputs.pred_masks)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f64bc619",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "input_points = [[[250, 200], [15, 50]]]\n",
+    "input_labels = [[[0, 1]]]\n",
+    "input_boxes = [[[100, 100, 400, 600]]]\n",
+    "\n",
+    "show_point_box(image, input_points[0], input_labels[0], input_boxes[0])\n",
+    "inputs = processor(\n",
+    "    image,\n",
+    "    input_points=input_points,\n",
+    "    input_labels=input_labels,\n",
+    "    input_boxes=input_boxes,\n",
+    "    return_tensors=\"pt\"\n",
+    ")\n",
+    "\n",
+    "model.eval()\n",
+    "with torch.no_grad():\n",
+    "    outputs = model(**inputs)\n",
+    "\n",
+    "masks = processor.image_processor.post_process_masks(\n",
+    "    outputs.pred_masks.cpu(),\n",
+    "    inputs[\"original_sizes\"].cpu(),\n",
+    "    inputs[\"reshaped_input_sizes\"].cpu(),\n",
+    ")\n",
+    "\n",
+    "show_masks_on_image(image, masks[0], outputs.iou_scores)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "dfe37f93",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "from transformers import pipeline\n",
+    "\n",
+    "generator = pipeline(\"mask-generation\", model=model_name)\n",
+    "outputs = generator(image, points_per_batch=32)\n",
+    "\n",
+    "plt.imshow(np.array(image))\n",
+    "ax = plt.gca()\n",
+    "for mask in outputs[\"masks\"]:\n",
+    "    show_mask(mask, ax=ax, random_color=True)\n",
+    "plt.axis(\"off\")\n",
+    "plt.show()\n",
+    "\n",
+    "print(\"outputs mask의 개수 :\", len(outputs[\"masks\"]))\n",
+    "print(\"outputs scores의 개수 :\", len(outputs[\"scores\"]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5277bdad",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "detector = pipeline(\n",
+    "    model=\"google/owlv2-base-patch16\", task=\"zero-shot-object-detection\"\n",
+    ")\n",
+    "\n",
+    "image = converted_dataset[24][\"img\"]\n",
+    "labels = [\"dog\", \"giraffe\"]\n",
+    "results = detector(image, candidate_labels=labels, threshold=0.5)\n",
+    "\n",
+    "input_boxes = []\n",
+    "for result in results:\n",
+    "    input_boxes.append(\n",
+    "        [\n",
+    "            result[\"box\"][\"xmin\"],\n",
+    "            result[\"box\"][\"ymin\"],\n",
+    "            result[\"box\"][\"xmax\"],\n",
+    "            result[\"box\"][\"ymax\"]\n",
+    "        ]\n",
+    "    )\n",
+    "    print(result)\n",
+    "\n",
+    "inputs = processor(image, input_boxes=[input_boxes], return_tensors=\"pt\")\n",
+    "\n",
+    "model.eval()\n",
+    "with torch.no_grad():\n",
+    "    outputs = model(**inputs)\n",
+    "\n",
+    "masks = processor.image_processor.post_process_masks(\n",
+    "    outputs.pred_masks.cpu(),\n",
+    "    inputs[\"original_sizes\"].cpu(),\n",
+    "    inputs[\"reshaped_input_sizes\"].cpu()\n",
+    ")\n",
+    "\n",
+    "plt.imshow(np.array(image))\n",
+    "ax = plt.gca()\n",
+    "\n",
+    "for mask, iou in zip(masks[0], outputs.iou_scores[0]):\n",
+    "    max_iou_idx = torch.argmax(iou)\n",
+    "    best_mask = mask[max_iou_idx]\n",
+    "    show_mask(best_mask, ax=ax, random_color=True)\n",
+    "\n",
+    "plt.axis(\"off\")\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

5장 멀티모달/예제 5.01 ~ 5.02 BLIP-2 모델 구조.ipynb

@@ -0,0 +1,60 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "da11820c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from transformers import Blip2Config\n",
+    "\n",
+    "model_name = \"Salesforce/blip2-opt-2.7b\"\n",
+    "config = Blip2Config.from_pretrained(model_name)\n",
+    "print(config)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6d3977dd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from transformers import Blip2ForConditionalGeneration\n",
+    "\n",
+    "model = Blip2ForConditionalGeneration(config)\n",
+    "\n",
+    "for main_name, main_module in model.named_children():\n",
+    "    print(main_name)\n",
+    "    for sub_name, sub_module in main_module.named_children():\n",
+    "        print(\"└\", sub_name)\n",
+    "        for ssub_name, ssub_module in sub_module.named_children():\n",
+    "            print(\"│  └\", ssub_name)\n",
+    "            for sssub_name, sssub_module in ssub_module.named_children():\n",
+    "                print(\"│    └\", sssub_name)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

5장 멀티모달/예제 5.03 ~ 5.05 BLIP-2 모델 작동 방식.ipynb

@@ -0,0 +1,120 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6d3977dd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "from datasets import load_dataset\n",
+    "from transformers import Blip2Processor, Blip2ForConditionalGeneration\n",
+    "\n",
+    "model_name = \"Salesforce/blip2-opt-2.7b\"\n",
+    "processor = Blip2Processor.from_pretrained(model_name)\n",
+    "model = Blip2ForConditionalGeneration.from_pretrained(\n",
+    "    model_name, torch_dtype=torch.float16, device_map=\"auto\"\n",
+    ")\n",
+    "\n",
+    "dataset = load_dataset(\"huggingface/cats-image\")\n",
+    "image = dataset[\"test\"][\"image\"][0]\n",
+    "\n",
+    "inputs = processor(images=image, return_tensors=\"pt\").to(\n",
+    "    model.device, dtype=torch.float16\n",
+    ")\n",
+    "image_embeds = model.vision_model(\n",
+    "    inputs[\"pixel_values\"], return_dict=True\n",
+    ").last_hidden_state\n",
+    "\n",
+    "print(model.vision_model)\n",
+    "print(image_embeds)\n",
+    "print(image_embeds.shape)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b9e4454f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "image_attention_mask = torch.ones(\n",
+    "    image_embeds.size()[:-1], dtype=torch.long, device=model.device\n",
+    ")\n",
+    "query_tokens = model.query_tokens.expand(image_embeds.shape[0], -1, -1)\n",
+    "\n",
+    "query_outputs = model.qformer(\n",
+    "    query_embeds=query_tokens,\n",
+    "    encoder_hidden_states=image_embeds,\n",
+    "    encoder_attention_mask=image_attention_mask,\n",
+    "    return_dict=True\n",
+    ")\n",
+    "query_output = query_outputs.last_hidden_state\n",
+    "\n",
+    "print(image_attention_mask.shape)\n",
+    "print(query_tokens.shape)\n",
+    "print(query_output.shape)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "53afdc60",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "language_model_inputs = model.language_projection(query_output)\n",
+    "language_attention_mask = torch.ones(\n",
+    "    language_model_inputs.size()[:-1],\n",
+    "    dtype=torch.long,\n",
+    "    device=model.device\n",
+    ")\n",
+    "input_ids = (\n",
+    "    torch.LongTensor([[model.config.text_config.bos_token_id]])\n",
+    "    .repeat(inputs[\"pixel_values\"].shape[0], 1)\n",
+    "    .to(model.device)\n",
+    ")\n",
+    "attention_mask = torch.ones_like(input_ids)\n",
+    "attention_mask = torch.cat(\n",
+    "    [language_attention_mask, attention_mask.to(model.device)], dim=1\n",
+    ")\n",
+    "\n",
+    "print(language_model_inputs.shape)\n",
+    "print(input_ids)\n",
+    "\n",
+    "inputs_embeds = model.get_input_embeddings()(input_ids)\n",
+    "inputs_embeds = torch.cat(\n",
+    "    [language_model_inputs, inputs_embeds.to(model.device)], dim=1\n",
+    ")\n",
+    "\n",
+    "outputs = model.language_model.generate(\n",
+    "    inputs_embeds=inputs_embeds, attention_mask=attention_mask, max_length=50\n",
+    ")\n",
+    "print(outputs)\n",
+    "print(outputs.shape)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

5장 멀티모달/예제 5.06 ~ 5.07 이미지 캡셔닝.ipynb

@@ -0,0 +1,76 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f3c6f204",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "from datasets import load_dataset\n",
+    "from transformers import Blip2Processor, Blip2ForConditionalGeneration\n",
+    "\n",
+    "model_name = \"Salesforce/blip2-opt-2.7b\"\n",
+    "processor = Blip2Processor.from_pretrained(model_name)\n",
+    "model = Blip2ForConditionalGeneration.from_pretrained(\n",
+    "    model_name, torch_dtype=torch.float16, device_map=\"auto\"\n",
+    ")\n",
+    "\n",
+    "dataset = load_dataset(\"huggingface/cats-image\")\n",
+    "image = dataset[\"test\"][\"image\"][0]\n",
+    "\n",
+    "inputs = processor(images=image, return_tensors=\"pt\").to(model.device, torch.float16)\n",
+    "generated_ids = model.generate(**inputs, max_length=50)\n",
+    "print(generated_ids)\n",
+    "\n",
+    "generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0].strip()\n",
+    "print(generated_text)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4b26083c",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "prompt = \"Question: Describe the location of the image. Answer:\"\n",
+    "inputs = processor(images=image, text=prompt, return_tensors=\"pt\").to(model.device, dtype=torch.float16)\n",
+    "\n",
+    "generated_ids = model.generate(**inputs, max_length=50)\n",
+    "generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0].strip()\n",
+    "print(generated_text)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

5장 멀티모달/예제 5.08 ~ 5.09 LayoutLMv3 모델 구조.ipynb

@@ -0,0 +1,68 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f3c6f204",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "from transformers import LayoutLMv3Config\n",
+    "\n",
+    "model_name = \"microsoft/layoutlmv3-base\"\n",
+    "config = LayoutLMv3Config(model_name)\n",
+    "print(config)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4b26083c",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "from transformers import LayoutLMv3Model\n",
+    "\n",
+    "model = LayoutLMv3Model.from_pretrained(model_name)\n",
+    "\n",
+    "for main_name, main_module in model.named_children():\n",
+    "    print(main_name)\n",
+    "    for sub_name, sub_module in main_module.named_children():\n",
+    "        print(\"└\", sub_name)\n",
+    "        for ssub_name, ssub_module in sub_module.named_children():\n",
+    "            print(\"│  └\", ssub_name)\n",
+    "            for sssub_name, sssub_module in ssub_module.named_children():\n",
+    "                print(\"│    └\", sssub_name)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

5장 멀티모달/예제 5.10 ~ 5.15 문서 시각 질의 응답.ipynb

@@ -0,0 +1,343 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "22628136",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "!pip3 install pytesseract"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ddf62285",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# # Windows\n",
+    "# import pytesseract\n",
+    "# pytesseract.pytesseract.tesseract_cmd = r\"<설치 경로>\\tesseract.exe\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e4bf6720",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# # macOS\n",
+    "# brew install tesseract"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b0d808bd",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# # Linux/Google Colab\n",
+    "# sudo apt install tesseract-ocr"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f3c6f204",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import io\n",
+    "from PIL import Image\n",
+    "from datasets import load_dataset\n",
+    "from transformers import LayoutLMv3FeatureExtractor\n",
+    "\n",
+    "def get_ocr_words_and_boxes(sample):\n",
+    "    image_bytes = io.BytesIO(sample[\"image\"])\n",
+    "    image = Image.open(image_bytes)\n",
+    "\n",
+    "    encoded_inputs = feature_extractor(image)\n",
+    "    sample[\"words\"] = encoded_inputs.words[0]\n",
+    "    sample[\"boxes\"] = encoded_inputs.boxes[0]\n",
+    "    sample[\"pixel_values\"] = encoded_inputs.pixel_values[0]\n",
+    "    return sample\n",
+    "\n",
+    "dataset = load_dataset(\"s076923/docvqa-train\")\n",
+    "model_name = \"microsoft/layoutlmv3-base\"\n",
+    "feature_extractor = LayoutLMv3FeatureExtractor(model_name)\n",
+    "dataset_with_ocr = dataset[\"train\"].map(get_ocr_words_and_boxes)\n",
+    "\n",
+    "print(dataset_with_ocr[1].keys())\n",
+    "print(\"question :\", dataset_with_ocr[1][\"question\"])\n",
+    "print(\"answers :\", dataset_with_ocr[1][\"answers\"])\n",
+    "print(\"words :\", dataset_with_ocr[1][\"words\"])\n",
+    "print(\"boxes :\", dataset_with_ocr[1][\"boxes\"])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4b26083c",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "def find_sublist(word_list, target_list):\n",
+    "    word_list = [word.lower() for word in word_list]\n",
+    "    target_list = target_list.lower().split()\n",
+    "\n",
+    "    for i in range(len(word_list) - len(target_list) + 1):\n",
+    "        if word_list[i : i + len(target_list)] == target_list:\n",
+    "            return target_list, i, i + len(target_list) - 1\n",
+    "    return None, 0, 0\n",
+    "\n",
+    "question = dataset_with_ocr[10][\"question\"]\n",
+    "words = dataset_with_ocr[10][\"words\"]\n",
+    "answers = dataset_with_ocr[10][\"answers\"]\n",
+    "print(question)\n",
+    "print(words)\n",
+    "print(answers)\n",
+    "print()\n",
+    "\n",
+    "for answer in answers:\n",
+    "    match, word_idx_start, word_idx_end = find_sublist(words, answer)\n",
+    "    print(\"Match :\", match)\n",
+    "    print(\"Word idx start :\", word_idx_start)\n",
+    "    print(\"Word idx end :\", word_idx_end)\n",
+    "    print()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "842dce7b",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "from transformers import LayoutLMv3TokenizerFast\n",
+    "from datasets import Features, Sequence, Value, Array2D, Array3D\n",
+    "\n",
+    "def find_answer_match(words, answers):\n",
+    "    for answer in answers:\n",
+    "        match, word_idx_start, word_idx_end = find_sublist(words, answer)\n",
+    "        if match:\n",
+    "            return match, word_idx_start, word_idx_end\n",
+    "\n",
+    "    for answer in answers:\n",
+    "        for i in range(len(answer)):\n",
+    "            answer_modified = answer[:i] + answer[i + 1 :]\n",
+    "            match, word_idx_start, word_idx_end = find_sublist(words, answer_modified)\n",
+    "            if match:\n",
+    "                return match, word_idx_start, word_idx_end\n",
+    "\n",
+    "    return False, None, None\n",
+    "\n",
+    "def encode_dataset(examples, processor, max_length=512):\n",
+    "    encoding = processor(\n",
+    "        examples[\"question\"],\n",
+    "        examples[\"words\"],\n",
+    "        examples[\"boxes\"],\n",
+    "        max_length=max_length,\n",
+    "        padding=\"max_length\",\n",
+    "        truncation=True\n",
+    "    )\n",
+    "\n",
+    "    cls_index = encoding.input_ids.index(processor.cls_token_id)\n",
+    "    start_position = end_position = cls_index\n",
+    "\n",
+    "    match, word_idx_start, word_idx_end = find_answer_match(\n",
+    "        examples[\"words\"], examples[\"answers\"]\n",
+    "    )\n",
+    "\n",
+    "    if match:\n",
+    "        sequence_ids = encoding.sequence_ids(0)\n",
+    "        token_start_index = next(i for i, seq_id in enumerate(sequence_ids) if seq_id == 1)\n",
+    "\n",
+    "        token_end_index = len(encoding.input_ids) - 1 - sequence_ids[::-1].index(1)\n",
+    "        word_ids = encoding.word_ids()[token_start_index : token_end_index + 1]\n",
+    "\n",
+    "        start_position = token_start_index + word_ids.index(word_idx_start)\n",
+    "        end_position = token_end_index - word_ids[::-1].index(word_idx_end)\n",
+    "\n",
+    "    encoding[\"image\"] = examples[\"pixel_values\"]\n",
+    "    encoding[\"start_positions\"] = start_position\n",
+    "    encoding[\"end_positions\"] = end_position\n",
+    "    return encoding\n",
+    "\n",
+    "processor = LayoutLMv3TokenizerFast.from_pretrained(model_name)\n",
+    "encoded_dataset = dataset_with_ocr.map(\n",
+    "    lambda x: encode_dataset(x, processor),\n",
+    "    remove_columns=dataset_with_ocr.column_names,\n",
+    "    features=Features(\n",
+    "        {\n",
+    "            \"input_ids\": Sequence(feature=Value(dtype=\"int64\")),\n",
+    "            \"bbox\": Array2D(dtype=\"int64\", shape=(512, 4)),\n",
+    "            \"attention_mask\": Sequence(Value(dtype=\"int64\")),\n",
+    "            \"image\": Array3D(dtype=\"float32\", shape=(3, 224, 224)),\n",
+    "            \"start_positions\": Value(dtype=\"int64\"),\n",
+    "            \"end_positions\": Value(dtype=\"int64\")\n",
+    "        }\n",
+    "    )\n",
+    ")\n",
+    "print(encoded_dataset)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1744922d",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "from transformers import TrainingArguments, Trainer\n",
+    "from transformers import LayoutLMv3ForQuestionAnswering\n",
+    "\n",
+    "model = LayoutLMv3ForQuestionAnswering.from_pretrained(model_name)\n",
+    "\n",
+    "training_args = TrainingArguments(\n",
+    "    output_dir=\"DocVQA\",\n",
+    "    num_train_epochs=20,\n",
+    "    per_device_train_batch_size=4,\n",
+    "    learning_rate=5e-5,\n",
+    "    warmup_steps=100,\n",
+    "    weight_decay=0.01,\n",
+    "    logging_strategy=\"steps\",\n",
+    "    logging_steps=20,\n",
+    "    seed=42\n",
+    ")\n",
+    "\n",
+    "trainer = Trainer(\n",
+    "    model=model,\n",
+    "    args=training_args,\n",
+    "    train_dataset=encoded_dataset\n",
+    ")\n",
+    "\n",
+    "trainer.train()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6453ba0f",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "from transformers import LayoutLMv3Processor\n",
+    "\n",
+    "index = 5\n",
+    "processor = LayoutLMv3Processor.from_pretrained(model_name)\n",
+    "\n",
+    "image_bytes = io.BytesIO(dataset_with_ocr[index][\"image\"])\n",
+    "image = Image.open(image_bytes)\n",
+    "\n",
+    "full_text = processor.decode(encoded_dataset[\"input_ids\"][index])\n",
+    "print(\"Full text:\", full_text)\n",
+    "\n",
+    "question = dataset_with_ocr[index][\"question\"]\n",
+    "print(\"Question:\", question)\n",
+    "\n",
+    "start_position = encoded_dataset[\"start_positions\"][index]\n",
+    "end_position = encoded_dataset[\"end_positions\"][index]\n",
+    "answer = processor.decode(\n",
+    "    encoded_dataset[\"input_ids\"][index][start_position : end_position + 1]\n",
+    ")\n",
+    "print(\"Answer:\", answer)\n",
+    "\n",
+    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
+    "encoded_inputs = processor(image, question, return_tensors=\"pt\")\n",
+    "encoded_inputs = {k: v.to(device) for k, v in encoded_inputs.items()}\n",
+    "print(\"Encoded input keys:\", encoded_inputs.keys())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "038dbe71",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "model.to(device)\n",
+    "model.eval()\n",
+    "\n",
+    "with torch.no_grad():\n",
+    "    outputs = model(**encoded_inputs)\n",
+    "\n",
+    "start_logits, end_logits = outputs.start_logits, outputs.end_logits\n",
+    "start_index = start_logits.argmax(-1).item()\n",
+    "end_index = end_logits.argmax(-1).item()\n",
+    "predicted_answer = processor.decode(\n",
+    "    encoded_inputs[\"input_ids\"].squeeze()[start_index : end_index + 1]\n",
+    ")\n",
+    "\n",
+    "print(\"Predicted start_index:\", start_index)\n",
+    "print(\"Predicted end_index:\", end_index)\n",
+    "print(\"predicted_answer:\", predicted_answer)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

5장 멀티모달/예제 5.16 ~ 5.17 ViLT 모델 구조 copy.ipynb

@@ -0,0 +1,60 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "da11820c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from transformers import ViltConfig\n",
+    "\n",
+    "model_name = \"dandelin/vilt-b32-mlm\"\n",
+    "config = ViltConfig.from_pretrained(model_name)\n",
+    "print(config)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6d3977dd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from transformers import ViltModel\n",
+    "\n",
+    "model = ViltModel.from_pretrained(model_name)\n",
+    "\n",
+    "for main_name, main_module in model.named_children():\n",
+    "    print(main_name)\n",
+    "    for sub_name, sub_module in main_module.named_children():\n",
+    "        print(\"└\", sub_name)\n",
+    "        for ssub_name, ssub_module in sub_module.named_children():\n",
+    "            print(\"│  └\", ssub_name)\n",
+    "            for sssub_name, sssub_module in ssub_module.named_children():\n",
+    "                print(\"│    └\", sssub_name)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}