From 9ae05d6df284c7c9e5f923c7a5bc3dfd55cb10b2 Mon Sep 17 00:00:00 2001 From: freylia <162332980+freylia@users.noreply.github.com> Date: Mon, 25 Nov 2024 04:54:46 +0900 Subject: [PATCH 1/2] =?UTF-8?q?Week=209=5F=EB=B3=B5=EC=8A=B5=EA=B3=BC?= =?UTF-8?q?=EC=A0=9C=5F=EC=A1=B0=EC=A3=BC=ED=98=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...354\241\260\354\243\274\355\230\204.ipynb" | 121 ++++++++++++++++++ 1 file changed, 121 insertions(+) create mode 100644 "Week9_\353\263\265\354\212\265\352\263\274\354\240\234_\354\241\260\354\243\274\355\230\204.ipynb" diff --git "a/Week9_\353\263\265\354\212\265\352\263\274\354\240\234_\354\241\260\354\243\274\355\230\204.ipynb" "b/Week9_\353\263\265\354\212\265\352\263\274\354\240\234_\354\241\260\354\243\274\355\230\204.ipynb" new file mode 100644 index 0000000..af4493a --- /dev/null +++ "b/Week9_\353\263\265\354\212\265\352\263\274\354\240\234_\354\241\260\354\243\274\355\230\204.ipynb" @@ -0,0 +1,121 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "MAyG6GGTU_mC", + "outputId": "4855f149-ae2a-4865-b021-8d6c3e47d1fb" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Net(\n", + " (conv1): Conv2d(1, 6, kernel_size=(5, 5), stride=(1, 1))\n", + " (conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))\n", + " (fc1): Linear(in_features=256, out_features=120, bias=True)\n", + " (fc2): Linear(in_features=120, out_features=84, bias=True)\n", + " (fc3): Linear(in_features=84, out_features=10, bias=True)\n", + ")\n" + ] + } + ], + "source": [ + "import torch\n", + "from torch.autograd import Variable\n", + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "\n", + "### 다음은 간단한 Convolutional Neural Network 모델 구조를 나타낸 코드입니다. 6장을 참고하여 아래 코드를 완성해주세요! ###\n", + "\n", + "class Net(nn.Module):\n", + "\n", + " def __init__(self):\n", + " super(Net, self).__init__()\n", + " \n", + " # 흑백 이미지(1개 채널)이며, 출력 채널은 6개이고 커널 크기는 5x5\n", + " self.conv1 = nn.Conv2d(1, 6, 5)\n", + " \n", + " # 입력은 ConvLayer의 출력, 출력 채널은 16개이고 커널 크기는 5x5\n", + " self.conv2 = nn.Conv2d(6, 16, 5)\n", + " \n", + " # 입력 크기는 Conv2의 출력 크기를 flatten한 값, 출력 크기는 120\n", + " self.fc1 = nn.Linear(16 * 4 * 4, 120)\n", + " \n", + " # 출력 크기 84\n", + " self.fc2 = nn.Linear(120, 84)\n", + " \n", + " # 출력 크기는 클래스 수(10개)\n", + " self.fc3 = nn.Linear(84, 10)\n", + " \n", + " def forward(self, x):\n", + " # (2, 2) 윈도우 크기로 맥스 풀링\n", + " \n", + " # Conv1 -> ReLU 활성화 -> MaxPooling\n", + " x = F.max_pool2d(x, 2) \n", + " \n", + " # Conv2 -> ReLU 활성화 -> MaxPooling\n", + " x = F.max_pool2d(x, 2)\n", + " \n", + " x = x.view(-1, self.num_flat_features(x))\n", + " \n", + " # FC1 -> ReLU 활성화\n", + " x = F.relu(self.fc1(x))\n", + " \n", + " # # FC2 -> ReLU 활성화\n", + " x = F.relu(self.fc2(x))\n", + " \n", + " x = self.fc3(x)\n", + " return x\n", + "\n", + "\n", + " def num_flat_features(self, x):\n", + " size = x.size()[1:] # 배치 차원을 제외한 모든 차원\n", + " num_features = 1\n", + " for s in size:\n", + " num_features *= s\n", + " return num_features\n", + "\n", + "\n", + "net = Net()\n", + "print(net)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "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.11.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} From e5f2e5c5dcdeaabec5e970ff103846ec9f4d7e18 Mon Sep 17 00:00:00 2001 From: freylia <162332980+freylia@users.noreply.github.com> Date: Tue, 24 Dec 2024 14:54:00 +0900 Subject: [PATCH 2/2] =?UTF-8?q?Week=2013=5F=EB=B3=B5=EC=8A=B5=EA=B3=BC?= =?UTF-8?q?=EC=A0=9C=5F=EC=A1=B0=EC=A3=BC=ED=98=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...354\241\260\354\243\274\355\230\204.ipynb" | 363 ++++++++++++++++++ 1 file changed, 363 insertions(+) create mode 100644 "Week13_\353\263\265\354\212\265\352\263\274\354\240\234_\354\241\260\354\243\274\355\230\204.ipynb" diff --git "a/Week13_\353\263\265\354\212\265\352\263\274\354\240\234_\354\241\260\354\243\274\355\230\204.ipynb" "b/Week13_\353\263\265\354\212\265\352\263\274\354\240\234_\354\241\260\354\243\274\355\230\204.ipynb" new file mode 100644 index 0000000..5210040 --- /dev/null +++ "b/Week13_\353\263\265\354\212\265\352\263\274\354\240\234_\354\241\260\354\243\274\355\230\204.ipynb" @@ -0,0 +1,363 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# **Description**\n", + "- 아래 코드는 **Dropout**과 **Batch Normalization** 기법을 사용하여 Digits 데이터셋에 대해 MLP 모델을 학습하는 코드입니다. \n", + "- PyTorch의 `nn.Sequential`을 사용해 모델을 간단히 정의하였습니다.\n", + " - 기본 모델 vs dropout 적용 모델 vs dropout + batch normalization 적용 모델의 test 결과 비교를 통해 각 기법의 영향을 알아보고자 합니다. \n", + "- 아래 모델 정의 코드 내에 `##답안 코드 작성##` 부분을 채우면서 코드를 실행시켜 주세요!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## **데이터 준비**" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "from torch import nn, optim\n", + "from torch.utils.data import TensorDataset, DataLoader\n", + "\n", + "from sklearn.datasets import load_digits\n", + "from sklearn.model_selection import train_test_split\n", + "from tqdm import tqdm\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "## 데이터를 훈련용과 테스트용으로 분리\n", + "# 전체의 20%는 검증용\n", + "\n", + "digits = load_digits()\n", + "\n", + "X = digits.data\n", + "Y = digits.target\n", + "X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size = 0.2)\n", + "\n", + "X_train = torch.tensor(X_train, dtype=torch.float32)\n", + "Y_train = torch.tensor(Y_train, dtype=torch.int64)\n", + "X_test = torch.tensor(X_test, dtype=torch.float32)\n", + "Y_test = torch.tensor(Y_test, dtype=torch.int64)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## **Dropout** \n", + "- **Dropout**은 **과적합 방지**를 위해 훈련 시 일부 노드를 확률 $p$로 무작위로 비활성화하는 기법입니다. \n", + " - 비활성화된 노드의 효과는 **스케일링** $\\frac{1}{1-p}$을 통해 살아남은 노드에 보상하여 전체 효과를 유지합니다. \n", + "- Dropout의 **훈련 단계**와 **평가 단계**의 작동 방식은 다릅니다. \n", + " - **훈련 단계** (`model.train()`): 일부 노드만 활성화되며 다양한 노드 조합을 학습해 **특정 노드 의존도를 줄입니다**. \n", + " - **평가 단계** (`model.eval()`): 드롭아웃이 비활성화되어 **모든 노드**가 사용되며, 스케일링도 적용되지 않아 **일관된 출력**을 제공합니다. \n", + "> 이를 통해 모델은 **훈련 시 일반화 성능**을 높이고, **평가 시 안정적 결과**를 도출합니다. \n", + "\n", + " \n", + "\n", + "(Image Source = https://d2l.ai/_images/dropout2.svg)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "### 모델링\n", + "## 힌트\n", + "# 입력층부터 출력층까지 선형층(Linear), ReLU 활성화 함수, 드롭아웃이 반복되는 구조\n", + "# 4개의 은닉층이 있으며 각 은닉층은 100개의 노드를 가짐\n", + "# dropout 기법으로 50% 확률로 노드를 비활성화함\n", + " \n", + "\n", + "import torch.nn as nn\n", + "\n", + "model = nn.Sequential(\n", + " nn.Linear(64, 100),\n", + " nn.ReLU(),\n", + " nn.Dropout(0.5),\n", + "\n", + " nn.Linear(100, 100),\n", + " nn.ReLU(),\n", + " nn.Dropout(0.5),\n", + "\n", + " nn.Linear(100, 100),\n", + " nn.ReLU(),\n", + " nn.Dropout(0.5),\n", + "\n", + " nn.Linear(100, 100),\n", + " nn.ReLU(),\n", + " nn.Dropout(0.5),\n", + " \n", + " nn.Linear(100, 10),\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "### Settings\n", + "\n", + "ds = TensorDataset(X_train, Y_train)\n", + "loader = DataLoader(ds, batch_size=32, shuffle=True)\n", + "\n", + "lossFunc = nn.CrossEntropyLoss()\n", + "optimizer = optim.Adam(model.parameters())" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████| 100/100 [00:38<00:00, 2.62it/s]\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "### 학습 & 평가\n", + "\n", + "trainLosses = []\n", + "testLosses = []\n", + "\n", + "for epoch in tqdm(range(100)):\n", + "\n", + " ## 학습(train)\n", + " runningLoss = 0.0\n", + " \n", + " model.train()\n", + "\n", + " for i, (batchX, batchY) in enumerate(loader):\n", + " optimizer.zero_grad()\n", + " yPred = model(batchX)\n", + " loss = lossFunc(yPred, batchY)\n", + " loss.backward()\n", + " optimizer.step()\n", + " runningLoss += loss.item()\n", + " trainLosses.append(runningLoss/i)\n", + " \n", + "\n", + " ## 평가(test)\n", + " model.eval()\n", + "\n", + " yPred = model(X_test)\n", + " testLoss = lossFunc(yPred, Y_test)\n", + " testLosses.append(testLoss.item())\n", + "\n", + "## 결과 시각화\n", + "plt.plot(range(100), trainLosses, label = \"train loss\")\n", + "plt.plot(range(100), testLosses, label = \"test loss\")\n", + "plt.legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## **Batch Normalization**\n", + "- **Batch Normalization**은 신경망의 각 층을 통과할 때 **데이터 분포가 변하는 문제**를 해결하기 위해 데이터를 정규화하는 기법입니다. \n", + "- 입력 데이터만 정규화하는 것으로는 부족하기 때문에, 각 층에서 배치 단위로 평균과 분산을 맞추어 학습을 더 **안정적**이고 **빠르게** 만듭니다. \n", + "- 훈련 시에는 배치 통계를 사용하고, 평가 시에는 훈련 중 기록한 평균과 분산을 사용합니다. \n", + "> 이를 통해 깊은 신경망도 안정적으로 학습할 수 있고 빠르게 수렴하도록 합니다. \n", + "\n", + " \n", + "\n", + "(Image Source: https://production-media.paperswithcode.com/methods/batchnorm.png)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "### 모델링\n", + "## 힌트\n", + "# 입력층부터 출력층까지 선형층(Linear), ReLU 활성화 함수, 배치정규화, 드롭아웃이 반복되는 구조\n", + "# 4개의 은닉층이 있으며 각 은닉층은 100개의 노드를 가짐\n", + "# dropout 기법으로 50% 확률로 노드를 비활성화함\n", + "# 배치 정규화할 출력 차원의 수는 100\n", + " \n", + "\n", + "import torch.nn as nn\n", + "\n", + "model = nn.Sequential(\n", + " nn.Linear(64, 100),\n", + " nn.ReLU(),\n", + " nn.BatchNorm1d(100),\n", + " nn.Dropout(0.5),\n", + "\n", + " nn.Linear(100, 100),\n", + " nn.ReLU(),\n", + " nn.BatchNorm1d(100),\n", + " nn.Dropout(0.5),\n", + "\n", + " nn.Linear(100, 100),\n", + " nn.ReLU(),\n", + " nn.BatchNorm1d(100),\n", + " nn.Dropout(0.5),\n", + "\n", + " nn.Linear(100, 100),\n", + " nn.ReLU(),\n", + " nn.BatchNorm1d(100),\n", + " nn.Dropout(0.5),\n", + " \n", + " nn.Linear(100, 10),\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "### Settings\n", + "\n", + "ds = TensorDataset(X_train, Y_train)\n", + "loader = DataLoader(ds, batch_size=32, shuffle=True)\n", + "\n", + "lossFunc = nn.CrossEntropyLoss()\n", + "optimizer = optim.Adam(model.parameters())" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████| 100/100 [00:50<00:00, 1.98it/s]\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "### 학습 & 평가\n", + "\n", + "trainLosses = []\n", + "testLosses = []\n", + "\n", + "for epoch in tqdm(range(100)):\n", + " ## 학습(train)\n", + " runningLoss = 0.0\n", + "\n", + " model.train()\n", + "\n", + " for i, (batchX, batchY) in enumerate(loader):\n", + " optimizer.zero_grad()\n", + " yPred = model(batchX)\n", + " loss = lossFunc(yPred, batchY)\n", + " loss.backward()\n", + " optimizer.step()\n", + " runningLoss += loss.item()\n", + " trainLosses.append(runningLoss/i)\n", + " \n", + " \n", + " ## 평가(test)\n", + " model.eval()\n", + "\n", + " yPred = model(X_test)\n", + " testLoss = lossFunc(yPred, Y_test)\n", + " testLosses.append(testLoss.item())\n", + "\n", + "### 시각화\n", + "plt.plot(range(100), trainLosses, label = \"train loss\")\n", + "plt.plot(range(100), testLosses, label = \"test loss\")\n", + "plt.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.11.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}