diff --git "a/Week1_\341\204\207\341\205\251\341\206\250\341\204\211\341\205\263\341\206\270\341\204\200\341\205\252\341\204\214\341\205\246_\341\204\222\341\205\241\341\206\253\341\204\211\341\205\256\341\204\213\341\205\247\341\206\253.ipynb" "b/Week1_\341\204\207\341\205\251\341\206\250\341\204\211\341\205\263\341\206\270\341\204\200\341\205\252\341\204\214\341\205\246_\341\204\222\341\205\241\341\206\253\341\204\211\341\205\256\341\204\213\341\205\247\341\206\253.ipynb"
new file mode 100644
index 0000000..a8a8ee7
--- /dev/null
+++ "b/Week1_\341\204\207\341\205\251\341\206\250\341\204\211\341\205\263\341\206\270\341\204\200\341\205\252\341\204\214\341\205\246_\341\204\222\341\205\241\341\206\253\341\204\211\341\205\256\341\204\213\341\205\247\341\206\253.ipynb"
@@ -0,0 +1,1201 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "9mabISNcCPiV"
+   },
+   "source": [
+    "# **Week1 복습과제**\n",
+    "\n",
+    "1. [Pytorch 기본]\n",
+    "1. [Linear Regression]\n",
+    "1. [Logistic Regression]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-09-14T14:41:13.574950Z",
+     "iopub.status.busy": "2026-09-14T14:41:13.574796Z",
+     "iopub.status.idle": "2026-09-14T14:41:14.197843Z",
+     "shell.execute_reply": "2026-09-14T14:41:14.196471Z"
+    },
+    "id": "T-Govjsw7kBQ"
+   },
+   "outputs": [],
+   "source": [
+    "# import libraries\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "#input data: 첨부된 .csv 파일 다운받아 사용해주세요"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "0qcO6qTxCUTU"
+   },
+   "source": [
+    "<a id=\"1\"></a> <br>\n",
+    "## 1. Pytorch 기본"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "execution": {
+     "iopub.execute_input": "2026-09-14T14:41:14.200450Z",
+     "iopub.status.busy": "2026-09-14T14:41:14.199464Z",
+     "iopub.status.idle": "2026-09-14T14:41:14.205175Z",
+     "shell.execute_reply": "2026-09-14T14:41:14.204694Z"
+    },
+    "id": "_KdP4S5g7udz",
+    "outputId": "86cf19f2-4ffd-495a-b8a6-8017820647b4"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Array Type: <class 'numpy.ndarray'>\n",
+      "Array Shape: (2, 3)\n",
+      "[[1 2 3]\n",
+      " [4 5 6]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# numpy array\n",
+    "array = [[1,2,3],[4,5,6]]\n",
+    "first_array = np.array(array) # 2x3 array\n",
+    "print(\"Array Type: {}\".format(type(first_array))) # type\n",
+    "print(\"Array Shape: {}\".format(first_array.shape)) # shape\n",
+    "print(first_array)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "HfLiM-u1Cj5l"
+   },
+   "source": [
+    "- 우리는 NumPy 배열을 살펴보았습니다.\n",
+    "- 이제 텐서(PyTorch 배열)를 구현하는 방법을 살펴보겠습니다.\n",
+    "- import torch를 사용하여 PyTorch 라이브러리를 가져옵니다.\n",
+    "- torch.Tensor() 메서드를 사용하여 텐서를 생성합니다.\n",
+    "- type: 배열의 타입을 나타냅니다. 이 예제에서는 텐서입니다.\n",
+    "- shape: 배열의 형태를 나타냅니다. (행 × 열)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "execution": {
+     "iopub.execute_input": "2026-09-14T14:41:14.240505Z",
+     "iopub.status.busy": "2026-09-14T14:41:14.240178Z",
+     "iopub.status.idle": "2026-09-14T14:41:16.331103Z",
+     "shell.execute_reply": "2026-09-14T14:41:16.330132Z"
+    },
+    "id": "d-uAA50o7ua4",
+    "outputId": "8b4d1429-da9f-4e02-e5f3-ab6fb829d1af"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Array Type: <class 'torch.Tensor'>\n",
+      "Array Shape: torch.Size([2, 3])\n",
+      "tensor([[1., 2., 3.],\n",
+      "        [4., 5., 6.]])\n"
+     ]
+    }
+   ],
+   "source": [
+    "# import pytorch library\n",
+    "import torch\n",
+    "\n",
+    "# pytorch array\n",
+    "tensor = torch.Tensor(array)\n",
+    "print(\"Array Type: {}\".format(type(tensor))) # type\n",
+    "print(\"Array Shape: {}\".format(tensor.shape)) # shape\n",
+    "print(tensor)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "pEvocwKPC6J1"
+   },
+   "source": [
+    "- 할당(Allocation)은 코딩에서 가장 많이 사용되는 기법 중 하나입니다.\n",
+    "- 따라서 PyTorch를 사용하여 이를 구현하는 방법을 배워봅시다.\n",
+    "- 학습을 위해 NumPy와 Tensor를 비교해 봅시다.\n",
+    "  - np.ones() = torch.ones()\n",
+    "  - np.random.rand() = torch.rand()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "execution": {
+     "iopub.execute_input": "2026-09-14T14:41:16.332845Z",
+     "iopub.status.busy": "2026-09-14T14:41:16.332675Z",
+     "iopub.status.idle": "2026-09-14T14:41:16.338892Z",
+     "shell.execute_reply": "2026-09-14T14:41:16.338096Z"
+    },
+    "id": "QlHQXzBR7uYo",
+    "outputId": "72b539d4-8b85-4e74-cb91-90c1d5f4d3d3"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Numpy [[1. 1. 1.]\n",
+      " [1. 1. 1.]]\n",
+      "\n",
+      "tensor([[1., 1., 1.],\n",
+      "        [1., 1., 1.]])\n"
+     ]
+    }
+   ],
+   "source": [
+    "# numpy ones\n",
+    "print(\"Numpy {}\\n\".format(np.ones((2,3)))) # 2x3 in numpy\n",
+    "\n",
+    "# pytorch ones\n",
+    "print(torch.ones((2,3))) # 2x3 in tensor\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "execution": {
+     "iopub.execute_input": "2026-09-14T14:41:16.340890Z",
+     "iopub.status.busy": "2026-09-14T14:41:16.340314Z",
+     "iopub.status.idle": "2026-09-14T14:41:16.345934Z",
+     "shell.execute_reply": "2026-09-14T14:41:16.345172Z"
+    },
+    "id": "xEV88BpO7uWc",
+    "outputId": "c1d05ebe-4fec-4ae3-cf72-3c42d67f8d6f"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Numpy [[0.49723166 0.67969093 0.22005028]\n",
+      " [0.42576613 0.03469096 0.05338322]]\n",
+      "\n",
+      "tensor([[0.1711, 0.8501, 0.2061],\n",
+      "        [0.3696, 0.2865, 0.4289]])\n"
+     ]
+    }
+   ],
+   "source": [
+    "# numpy random\n",
+    "print(\"Numpy {}\\n\".format(np.random.rand(2,3))) # 2x3 random numpy array\n",
+    "\n",
+    "# pytorch random\n",
+    "print(torch.rand(2,3)) # 2x3 random tensor\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "2TAOGUteDLOv"
+   },
+   "source": [
+    "- 텐서와 NumPy 배열 간의 변환을 살펴봅시다.\n",
+    "  - torch.from_numpy(): NumPy → Tensor\n",
+    "  - .numpy(): Tensor → NumPy"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "execution": {
+     "iopub.execute_input": "2026-09-14T14:41:16.348115Z",
+     "iopub.status.busy": "2026-09-14T14:41:16.347519Z",
+     "iopub.status.idle": "2026-09-14T14:41:16.353997Z",
+     "shell.execute_reply": "2026-09-14T14:41:16.353240Z"
+    },
+    "id": "yWShZwKC7uUM",
+    "outputId": "c287e9ff-aede-4a96-e91d-d68993605be7"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<class 'numpy.ndarray'> [[0.56367866 0.89817031]\n",
+      " [0.34648879 0.19504871]]\n",
+      "\n",
+      "tensor([[0.5637, 0.8982],\n",
+      "        [0.3465, 0.1950]], dtype=torch.float64)\n",
+      "\n",
+      "<class 'numpy.ndarray'> [[0.56367866 0.89817031]\n",
+      " [0.34648879 0.19504871]]\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# random numpy array\n",
+    "array = np.random.rand(2,2)\n",
+    "print(\"{} {}\\n\".format(type(array), array))\n",
+    "\n",
+    "# numpy -> tensor\n",
+    "from_numpy_to_tensor = torch.from_numpy(array)\n",
+    "print(\"{}\\n\".format(from_numpy_to_tensor))\n",
+    "\n",
+    "# tensor -> numpy\n",
+    "tensor = from_numpy_to_tensor\n",
+    "from_tensor_to_numpy = tensor.numpy()\n",
+    "print(\"{} {}\\n\".format(type(from_tensor_to_numpy),from_tensor_to_numpy))\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "bsJkMU_lDZgy"
+   },
+   "source": [
+    "### PyTorch 기본 수학 연산\n",
+    "- 크기 변경(Resize): view()\n",
+    "- a와 b는 텐서입니다.\n",
+    "- 덧셈(Addition): torch.add(a, b) = a + b\n",
+    "- 뺄셈(Subtraction): a.sub(b) = a - b\n",
+    "- 원소별 곱(Element-wise Multiplication): torch.mul(a, b) = a * b\n",
+    "- 원소별 나눗셈(Element-wise Division): torch.div(a, b) = a / b\n",
+    "- 평균(Mean): a.mean()\n",
+    "- 표준 편차(Standard Deviation, std): a.std()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "execution": {
+     "iopub.execute_input": "2026-09-14T14:41:16.356253Z",
+     "iopub.status.busy": "2026-09-14T14:41:16.355602Z",
+     "iopub.status.idle": "2026-09-14T14:41:16.367406Z",
+     "shell.execute_reply": "2026-09-14T14:41:16.366439Z"
+    },
+    "id": "V6iLiAPS7uQs",
+    "outputId": "68e93d21-7b80-425a-998b-3c0bc7e97654"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      " tensor([[1., 1., 1.],\n",
+      "        [1., 1., 1.],\n",
+      "        [1., 1., 1.]])\n",
+      "torch.Size([9])tensor([1., 1., 1., 1., 1., 1., 1., 1., 1.])\n",
+      "\n",
+      "Addition: tensor([[2., 2., 2.],\n",
+      "        [2., 2., 2.],\n",
+      "        [2., 2., 2.]])\n",
+      "\n",
+      "Subtraction: tensor([[0., 0., 0.],\n",
+      "        [0., 0., 0.],\n",
+      "        [0., 0., 0.]])\n",
+      "\n",
+      "Element wise multiplication: tensor([[1., 1., 1.],\n",
+      "        [1., 1., 1.],\n",
+      "        [1., 1., 1.]])\n",
+      "\n",
+      "Element wise division: tensor([[1., 1., 1.],\n",
+      "        [1., 1., 1.],\n",
+      "        [1., 1., 1.]])\n",
+      "\n",
+      "Mean: 3.0\n",
+      "std: 1.5811388492584229\n"
+     ]
+    }
+   ],
+   "source": [
+    "# 텐서 생성\n",
+    "tensor = torch.ones(3,3)\n",
+    "print(\"\\n\",tensor)\n",
+    "\n",
+    "# 크기 변경\n",
+    "print(\"{}{}\\n\".format(tensor.view(9).shape,tensor.view(9)))\n",
+    "\n",
+    "# 덧셈\n",
+    "print(\"Addition: {}\\n\".format(torch.add(tensor,tensor)))\n",
+    "\n",
+    "# 뺄셈\n",
+    "print(\"Subtraction: {}\\n\".format(tensor.sub(tensor)))\n",
+    "\n",
+    "# 원소별 곱\n",
+    "print(\"Element wise multiplication: {}\\n\".format(torch.mul(tensor,tensor)))\n",
+    "\n",
+    "# 원소별 나눗셈\n",
+    "print(\"Element wise division: {}\\n\".format(torch.div(tensor,tensor)))\n",
+    "\n",
+    "# 평균\n",
+    "tensor = torch.Tensor([1,2,3,4,5])\n",
+    "print(\"Mean: {}\".format(tensor.mean()))\n",
+    "\n",
+    "# 표준편차\n",
+    "print(\"std: {}\".format(tensor.std()))\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "HxVIlKSQEIXx"
+   },
+   "source": [
+    "### Variables  \n",
+    "- 변수는 그래디언트(Gradients)를 누적합니다.\n",
+    "- 우리는 PyTorch를 신경망에 사용할 것입니다. 신경망에서는 역전파(Backpropagation) 과정에서 그래디언트를 계산하게 됩니다. 따라서 그래디언트를 다룰 필요가 있습니다.\n",
+    "- 변수(Variable)와 텐서(Tensor)의 차이점은 변수가 그래디언트를 누적한다는 것입니다.  \n",
+    "- 변수를 사용하여 수학 연산을 수행할 수도 있습니다.  \n",
+    "- 역전파를 수행하려면 변수가 필요합니다."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "execution": {
+     "iopub.execute_input": "2026-09-14T14:41:16.368951Z",
+     "iopub.status.busy": "2026-09-14T14:41:16.368802Z",
+     "iopub.status.idle": "2026-09-14T14:41:16.377083Z",
+     "shell.execute_reply": "2026-09-14T14:41:16.376240Z"
+    },
+    "id": "UfpDKji97uOv",
+    "outputId": "0d42e630-cb02-4bcb-b4ec-643186d3383f"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "tensor([1., 1., 1.], requires_grad=True)"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from torch.autograd import Variable\n",
+    "\n",
+    "# variable 정의\n",
+    "var = Variable(torch.ones(3), requires_grad = True)\n",
+    "var\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "execution": {
+     "iopub.execute_input": "2026-09-14T14:41:16.378667Z",
+     "iopub.status.busy": "2026-09-14T14:41:16.378512Z",
+     "iopub.status.idle": "2026-09-14T14:41:16.389063Z",
+     "shell.execute_reply": "2026-09-14T14:41:16.388277Z"
+    },
+    "id": "t4p2w1z_7uMv",
+    "outputId": "27e22648-5a54-42cb-e4d6-c1f5281a1a33"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " y =   tensor([ 4., 16.], grad_fn=<PowBackward0>)\n",
+      " o =   tensor(10., grad_fn=<MulBackward0>)\n",
+      "gradients:  tensor([2., 4.])\n"
+     ]
+    }
+   ],
+   "source": [
+    "# 기본적인 역전파(backward propagation) 수행\n",
+    "# 주어진 함수 y = x^2\n",
+    "array = [2,4]\n",
+    "tensor = torch.Tensor(array)\n",
+    "x = Variable(tensor, requires_grad = True)\n",
+    "y = x**2\n",
+    "print(\" y =  \",y)\n",
+    "\n",
+    "# 방정식 요약: o = 1/2*sum(y)\n",
+    "o = (1/2)*sum(y)\n",
+    "print(\" o =  \",o)\n",
+    "\n",
+    "# 역전파 실행(그래디언트 계산)\n",
+    "o.backward()\n",
+    "\n",
+    "# 변수는 그래디언트를 누적. 여기서는 x 하나만 존재.\n",
+    "# 따라선 변수 x는 그래디언트를 가져야 함\n",
+    "# x의 그래디언트 출력\n",
+    "print(\"gradients: \",x.grad)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Jq1tID2f9DOP"
+   },
+   "source": [
+    "<a id=\"2\"></a> <br>\n",
+    "## 2. 선형 회귀\n",
+    "\n",
+    "- y = Ax + B\n",
+    "    - A = 기울기\n",
+    "    - B = 절편 (y축과 교차하는 점)\n",
+    "\n",
+    "- 자동차 가격이 낮으면 더 많이 팔리고, 자동차 가격이 높으면 덜 팔린다는 사실을 우리는 알고 있으며, 이에 대한 데이터셋을 가지고 있습니다.\n",
+    "\n",
+    "- 목표는 자동차 가격이 100일 때 팔린 자동차의 수를 예측하는 것입니다."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 472
+    },
+    "execution": {
+     "iopub.execute_input": "2026-09-14T14:41:16.391286Z",
+     "iopub.status.busy": "2026-09-14T14:41:16.390597Z",
+     "iopub.status.idle": "2026-09-14T14:41:16.525362Z",
+     "shell.execute_reply": "2026-09-14T14:41:16.524319Z"
+    },
+    "id": "5r4kXCwf7uKP",
+    "outputId": "4db996a9-d5d9-4a7d-89a4-6cc1cc9c8c5f"
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# 자동차 회사에서 과거 판매 데이터를 수집했다고 가정\n",
+    "# 자동차 가격 데이터 정의\n",
+    "car_prices_array = [3,4,5,6,7,8,9]\n",
+    "car_price_np = np.array(car_prices_array,dtype=np.float32) # numpy array로 변환\n",
+    "car_price_np = car_price_np.reshape(-1,1) #reshape\n",
+    "car_price_tensor = Variable(torch.from_numpy(car_price_np)) # define variable\n",
+    "\n",
+    "# 자동차 판매량 데이터 정의\n",
+    "number_of_car_sell_array = [ 7.5, 7, 6.5, 6.0, 5.5, 5.0, 4.5]\n",
+    "number_of_car_sell_np = np.array(number_of_car_sell_array,dtype=np.float32) # numpy array 로 변환\n",
+    "number_of_car_sell_np = number_of_car_sell_np.reshape(-1,1) #reshape\n",
+    "number_of_car_sell_tensor = Variable(torch.from_numpy(number_of_car_sell_np)) # define variable\n",
+    "\n",
+    "# 데이터 시각화\n",
+    "import matplotlib.pyplot as plt\n",
+    "plt.scatter(car_prices_array,number_of_car_sell_array)\n",
+    "plt.xlabel(\"Car Price $\")\n",
+    "plt.ylabel(\"Number of Car Sell\")\n",
+    "plt.title(\"Car Price$ VS Number of Car Sell\")\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "MOlzmdG89JCT"
+   },
+   "source": [
+    "- 이제 이 그래프는 우리가 수집한 데이터입니다.\n",
+    "- 우리는 자동차 가격이 100달러일 때 판매된 자동차의 수가 무엇일지를 묻는 질문을 가지고 있습니다.\n",
+    "- 이 질문을 해결하기 위해 우리는 선형 회귀를 사용해야 합니다.\n",
+    "- 우리는 이 데이터에 맞는 선을 찾아야 합니다. 목표는 최소한의 오류로 선을 맞추는 것입니다.\n",
+    "\n",
+    "---\n",
+    "\n",
+    "- **선형 회귀의 단계**\n",
+    "    1. LinearRegression 클래스를 생성합니다.\n",
+    "    2. 이 LinearRegression 클래스로 모델을 정의합니다.\n",
+    "    3. MSE: 평균 제곱 오차(Mean Squared Error)\n",
+    "    4. 최적화 (SGD: 확률적 경사 하강법)\n",
+    "    5. 역전파 (Backpropagation)\n",
+    "    6. 예측 (Prediction)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 835
+    },
+    "execution": {
+     "iopub.execute_input": "2026-09-14T14:41:16.527923Z",
+     "iopub.status.busy": "2026-09-14T14:41:16.527123Z",
+     "iopub.status.idle": "2026-09-14T14:41:18.353091Z",
+     "shell.execute_reply": "2026-09-14T14:41:18.352097Z"
+    },
+    "id": "6MvDUc9b7uHf",
+    "outputId": "ce7b6494-8cfd-48b3-ae1e-776b6d0ad897"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 0, loss 56.3978385925293\n",
+      "epoch 50, loss 4.396064281463623\n",
+      "epoch 100, loss 2.970604658126831\n",
+      "epoch 150, loss 2.0073611736297607\n",
+      "epoch 200, loss 1.3564592599868774\n",
+      "epoch 250, loss 0.9166159629821777\n",
+      "epoch 300, loss 0.6193960309028625\n",
+      "epoch 350, loss 0.41855207085609436\n",
+      "epoch 400, loss 0.28283265233039856\n",
+      "epoch 450, loss 0.19112205505371094\n",
+      "epoch 500, loss 0.12914958596229553\n",
+      "epoch 550, loss 0.08727167546749115\n",
+      "epoch 600, loss 0.058972883969545364\n",
+      "epoch 650, loss 0.03985034301877022\n",
+      "epoch 700, loss 0.026928631588816643\n",
+      "epoch 750, loss 0.018196946009993553\n",
+      "epoch 800, loss 0.012296540662646294\n",
+      "epoch 850, loss 0.008309260942041874\n",
+      "epoch 900, loss 0.005614925175905228\n",
+      "epoch 950, loss 0.003794262884184718\n",
+      "epoch 1000, loss 0.0025639834348112345\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# PyTorch를 이용한 선형 회귀 모델 구현\n",
+    "\n",
+    "import torch\n",
+    "from torch.autograd import Variable\n",
+    "import torch.nn as nn\n",
+    "import warnings\n",
+    "warnings.filterwarnings(\"ignore\")\n",
+    "\n",
+    "# 선형 회귀 클래스 정의\n",
+    "class LinearRegression(nn.Module):\n",
+    "    def __init__(self, input_size, output_size):\n",
+    "        super(LinearRegression, self).__init__()\n",
+    "        self.linear = nn.Linear(input_size, output_size) # apply linear function\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        return self.linear(x)\n",
+    "\n",
+    "# 모델 정의\n",
+    "input_dim = 1\n",
+    "output_dim = 1\n",
+    "model = LinearRegression(input_dim,output_dim)\n",
+    "\n",
+    "# 손실 함수 (MSE)\n",
+    "mse = nn.MSELoss()\n",
+    "\n",
+    "# 옵티마이저 (SGD 사용)\n",
+    "learning_rate = 0.02\n",
+    "optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)\n",
+    "\n",
+    "# 모델 학습\n",
+    "loss_list = []\n",
+    "iteration_number = 1001\n",
+    "for iteration in range(iteration_number):\n",
+    "    optimizer.zero_grad()  # 기울기 초기화\n",
+    "    results = model(car_price_tensor)  # 예측값 계산\n",
+    "    loss = mse(results, number_of_car_sell_tensor) # 손실 계산\n",
+    "    # 역전파 실행\n",
+    "    loss.backward()\n",
+    "    # 가중치 업데이트\n",
+    "    optimizer.step()\n",
+    "    # loss 저장\n",
+    "    loss_list.append(loss.data)\n",
+    "    # loss 출력\n",
+    "    if iteration % 50 == 0:\n",
+    "        print(f'epoch {iteration}, loss {loss.data}')\n",
+    "\n",
+    "# 손실 그래프 시각화\n",
+    "plt.plot(range(iteration_number), loss_list)\n",
+    "plt.xlabel(\"Number of Iterations\")\n",
+    "plt.ylabel(\"Loss\")\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "9odY_Wb59N8H"
+   },
+   "source": [
+    "- 반복 횟수는 1000입니다.\n",
+    "- 손실 값은 거의 0에 가까우며, 이는 그래프나 1000번째 epoch에서의 손실 값에서 확인할 수 있습니다.\n",
+    "- 이제 우리는 훈련된 모델을 가지고 있습니다.\n",
+    "- 훈련된 모델을 사용할 때, 자동차 가격을 예측해 봅시다."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 472
+    },
+    "execution": {
+     "iopub.execute_input": "2026-09-14T14:41:18.355911Z",
+     "iopub.status.busy": "2026-09-14T14:41:18.354843Z",
+     "iopub.status.idle": "2026-09-14T14:41:18.493246Z",
+     "shell.execute_reply": "2026-09-14T14:41:18.492225Z"
+    },
+    "id": "FtsHa2uk7uDy",
+    "outputId": "b4367f4b-e340-48d0-ec29-a30a1fc53f46"
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAHHCAYAAABDUnkqAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAYMhJREFUeJzt3XlcVFX/B/DPMKyyucSm7IoCigiaikrKo0VuaaQpmbtmuYF7/swtU1weDVxyyQItd0WfNBO1xHDHhXLBHQURtZRFXEBmzu8PYnJkcQaGGR0+79frvuqec+693zui8+Wcc8+VCCEEiIiIiPSEga4DICIiItIkJjdERESkV5jcEBERkV5hckNERER6hckNERER6RUmN0RERKRXmNwQERGRXmFyQ0RERHqFyQ0RERHpFSY3RJVkxowZkEgk5To2JiYGEokEN27c0GxQz7lx4wYkEgliYmIq7RqvC1dXVwwYMECxHx8fD4lEgvj4eJ3F9KIXY9QWiUSCGTNmaP26RBXB5IboBefPn8fHH3+MOnXqwMTEBLVr10afPn1w/vx5XYeml4oSuaLN1NQU9evXx8iRI3H37l1dh6eW3bt3MxEgegUwuSF6TmxsLPz9/fHrr79i4MCB+OabbzB48GAcOHAA/v7+2L59u8rn+uKLL/DkyZNyxdG3b188efIELi4u5Tr+dfTll1/ihx9+wNKlS9GqVSssX74cAQEBePz4sdZjeeutt/DkyRO89dZbah23e/duzJw5s5KiIiJVGeo6AKJXxbVr19C3b1+4u7vj999/h42NjaIuLCwMgYGB6Nu3L/7880+4u7uXep5Hjx7B3NwchoaGMDQs318xqVQKqVRarmNfVx07dkSzZs0AAEOGDEGtWrWwaNEi/O9//0NoaGiJxxR91ppmYGAAU1NTjZ+XiLSDPTdE/1iwYAEeP36MVatWKSU2APDGG29g5cqVePToEebPn68oL5pXc+HCBXz00UeoUaMG2rRpo1T3vCdPnmD06NF44403YGlpiffeew/p6enF5jWUNOfG1dUVXbp0waFDh9C8eXOYmprC3d0da9euVbrGgwcPMH78ePj4+MDCwgJWVlbo2LEj/vjjD7U/k5MnT0IikWDNmjXF6uLi4iCRSLBr1y4AwMOHDxEeHg5XV1eYmJjA1tYWb7/9Nk6fPq32dQHgP//5DwAgJSUFADBgwABYWFjg2rVr6NSpEywtLdGnTx8AgFwuR2RkJBo2bAhTU1PY2dlh2LBhyMzMVDqnEAJfffUVHB0dUa1aNQQFBZU43FjanJvjx4+jU6dOqFGjBszNzdG4cWNERUUp4lu2bBkAKA2zFdF0jC969uwZatasiYEDBxary8nJgampKcaPHw8AyM/Px7Rp09C0aVNYW1vD3NwcgYGBOHDgwEuvM2DAALi6uhYrL22O2Y8//oimTZvCzMwMNWvWRO/evZGWlqbU5sqVK/jggw9gb28PU1NTODo6onfv3sjOzn5pPEQlYc8N0T927twJV1dXBAYGllj/1ltvwdXVFT///HOxup49e8LDwwNz5syBEKLUawwYMACbN29G37590bJlSxw8eBCdO3dWOcarV6+iR48eGDx4MPr374/vv/8eAwYMQNOmTdGwYUMAwPXr17Fjxw707NkTbm5uuHv3LlauXIm2bdviwoULqF27tsrXa9asGdzd3bF582b0799fqW7Tpk2oUaMGgoODAQCffvoptm7dipEjR8Lb2xv379/HoUOHkJycDH9/f5WvWeTatWsAgFq1ainKCgoKEBwcjDZt2uC///0vqlWrBgAYNmwYYmJiMHDgQIwePRopKSlYunQpzpw5g8OHD8PIyAgAMG3aNHz11Vfo1KkTOnXqhNOnT+Odd95Bfn7+S+PZt28funTpAgcHB4SFhcHe3h7JycnYtWsXwsLCMGzYMNy+fRv79u3DDz/8UOz4yo7RyMgI77//PmJjY7Fy5UoYGxsr6nbs2IG8vDz07t0bQGGys3r1aoSGhmLo0KF4+PAhvvvuOwQHB+PEiRNo0qTJSz8PVcyePRtTp07Fhx9+iCFDhuCvv/7CkiVL8NZbb+HMmTOoXr068vPzERwcjLy8PIwaNQr29vZIT0/Hrl27kJWVBWtra43EQlWMICKRlZUlAIhu3bqV2e69994TAEROTo4QQojp06cLACI0NLRY26K6IqdOnRIARHh4uFK7AQMGCABi+vTpirLo6GgBQKSkpCjKXFxcBADx+++/K8ru3bsnTExMxLhx4xRlT58+FTKZTOkaKSkpwsTERHz55ZdKZQBEdHR0mfc8efJkYWRkJB48eKAoy8vLE9WrVxeDBg1SlFlbW4sRI0aUea6SFN3r/v37xV9//SXS0tLExo0bRa1atYSZmZm4deuWEEKI/v37CwDi888/Vzo+ISFBABDr1q1TKt+zZ49S+b1794SxsbHo3LmzkMvlinb/93//JwCI/v37K8oOHDggAIgDBw4IIYQoKCgQbm5uwsXFRWRmZipd5/lzjRgxQpT0z2plxFiSuLg4AUDs3LlTqbxTp07C3d1dsV9QUCDy8vKU2mRmZgo7OzulP1MhRLGfzf79+wsXF5di137x5/3GjRtCKpWK2bNnK7U7e/asMDQ0VJSfOXNGABBbtmwp896I1MFhKSIUDqkAgKWlZZntiupzcnKUyj/99NOXXmPPnj0AgOHDhyuVjxo1SuU4vb29lXqWbGxs0KBBA1y/fl1RZmJiAgODwr/aMpkM9+/fh4WFBRo0aFCuIaJevXrh2bNniI2NVZTt3bsXWVlZ6NWrl6KsevXqOH78OG7fvq32NQCgQ4cOsLGxgZOTE3r37g0LCwts374dderUUWr32WefKe1v2bIF1tbWePvtt/H3338rtqZNm8LCwkIx1LJ//37k5+dj1KhRSsMn4eHhL43tzJkzSElJQXh4OKpXr65Up8rj/tqIESgcynvjjTewadMmRVlmZib27dun9GcllUoVPTtyuRwPHjxAQUEBmjVrVu5hxBfFxsZCLpfjww8/VLpne3t7eHh4KO65qGcmLi5OJ5PHST9xWIoI/yYtRUlOaUpLgtzc3F56jZs3b8LAwKBY23r16qkcp7Ozc7GyGjVqKM3bkMvliIqKwjfffIOUlBTIZDJF3fNDPKry9fWFp6cnNm3ahMGDBwMoHJJ64403FPNiAGD+/Pno378/nJyc0LRpU3Tq1An9+vUrc/L185YtW4b69evD0NAQdnZ2aNCggSJJK2JoaAhHR0elsitXriA7Oxu2trYlnvfevXsACj9/APDw8FCqt7GxQY0aNcqMrWiIrFGjRirdy4u0ESNQ+Pl88MEHWL9+PfLy8mBiYoLY2Fg8e/ZMKbkBgDVr1mDhwoW4ePEinj17pihX5WdZFVeuXIEQoti9FCkahnNzc8PYsWOxaNEirFu3DoGBgXjvvffw8ccfc0iKyo3JDREKf3t0cHDAn3/+WWa7P//8E3Xq1IGVlZVSuZmZWWWGp1DaE1TiuXk+c+bMwdSpUzFo0CDMmjULNWvWhIGBAcLDwyGXy8t13V69emH27Nn4+++/YWlpiZ9++gmhoaFKT4N9+OGHCAwMxPbt27F3714sWLAA8+bNQ2xsLDp27PjSazRv3lzxtFRpnu+VKiKXy2Fra4t169aVeMyLk8N1QZsx9u7dGytXrsQvv/yC7t27Y/PmzfD09ISvr6+izY8//ogBAwage/fumDBhAmxtbSGVShEREaFI5EpTWk/V80k0UHjPEokEv/zyS4k/txYWFor/X7hwIQYMGID//e9/2Lt3L0aPHo2IiAgcO3asWDJLpAomN0T/6NKlC7799lscOnRI8cTT8xISEnDjxg0MGzasXOd3cXGBXC5HSkqK0m+zV69eLXfMJdm6dSuCgoLw3XffKZVnZWXhjTfeKNc5e/XqhZkzZ2Lbtm2ws7NDTk6OYnLq8xwcHDB8+HAMHz4c9+7dg7+/P2bPnq1SclNedevWxf79+9G6desyk8yiNYOuXLmi1Jv0119/FXtiqaRrAMC5c+fQoUOHUtuV9sWvjRiLvPXWW3BwcMCmTZvQpk0b/Pbbb5gyZYpSm61bt8Ld3R2xsbFKMU+fPv2l569RowaysrKKlRf1OhWpW7cuhBBwc3ND/fr1X3peHx8f+Pj44IsvvsCRI0fQunVrrFixAl999dVLjyV6EefcEP1jwoQJMDMzw7Bhw3D//n2lugcPHuDTTz9FtWrVMGHChHKdv+ipom+++UapfMmSJeULuBRSqbTYE1tbtmxBenp6uc/p5eUFHx8fbNq0CZs2bYKDg4PSAncymazYY7u2traoXbs28vLyyn1dVXz44YeQyWSYNWtWsbqCggLFF3GHDh1gZGSEJUuWKH0+kZGRL72Gv78/3NzcEBkZWeyL/flzFa2582IbbcRYxMDAAD169MDOnTvxww8/oKCgoNiQVFFPyvPXOH78OI4ePfrS89etWxfZ2dlKvZwZGRnFFrgMCQmBVCrFzJkzi/08CiEUf8dycnJQUFCgVO/j4wMDA4NK/9kh/cWeG6J/eHh4YM2aNejTpw98fHwwePBguLm54caNG/juu+/w999/Y8OGDYrf4tXVtGlTfPDBB4iMjMT9+/cVj4JfvnwZgGoTU1XRpUsXfPnllxg4cCBatWqFs2fPYt26dSrPfSlNr169MG3aNJiammLw4MFKw0MPHz6Eo6MjevToAV9fX1hYWGD//v1ITEzEwoULK3pLZWrbti2GDRuGiIgIJCUl4Z133oGRkRGuXLmCLVu2ICoqCj169ICNjQ3Gjx+PiIgIdOnSBZ06dcKZM2fwyy+/vLRHy8DAAMuXL0fXrl3RpEkTDBw4EA4ODrh48SLOnz+PuLg4AIV/xgAwevRoBAcHQyqVonfv3lqJ8Xm9evXCkiVLMH36dPj4+MDLy0upvkuXLoiNjcX777+Pzp07IyUlBStWrIC3tzdyc3PLPHfv3r0xadIkvP/++xg9ejQeP36M5cuXo379+kqTkevWrYuvvvoKkydPxo0bN9C9e3dYWloiJSUF27dvxyeffILx48fjt99+w8iRI9GzZ0/Ur18fBQUF+OGHHyCVSvHBBx+ofM9ESnT1mBbRq+rPP/8UoaGhwsHBQRgZGQl7e3sRGhoqzp49W6xt0eOvf/31V6l1z3v06JEYMWKEqFmzprCwsBDdu3cXly5dEgDE3LlzFe1KexS8c+fOxa7Ttm1b0bZtW8X+06dPxbhx44SDg4MwMzMTrVu3FkePHi3WTtVHwYtcuXJFABAAxKFDh5Tq8vLyxIQJE4Svr6+wtLQU5ubmwtfXV3zzzTcvPW/RvSYmJpbZrn///sLc3LzU+lWrVommTZsKMzMzYWlpKXx8fMTEiRPF7du3FW1kMpmYOXOm4rNp166dOHfunHBxcSnzUfAihw4dEm+//bbiHhs3biyWLFmiqC8oKBCjRo0SNjY2QiKRFPvz12SMZZHL5cLJyUkAEF999VWJ9XPmzBEuLi7CxMRE+Pn5iV27dpX4mDdeeBRcCCH27t0rGjVqJIyNjUWDBg3Ejz/+WOLPuxBCbNu2TbRp00aYm5sLc3Nz4enpKUaMGCEuXbokhBDi+vXrYtCgQaJu3brC1NRU1KxZUwQFBYn9+/erdK9EJZEIUcaKY0RU6ZKSkuDn54cff/xRseIuERGVH+fcEGlRSS/SjIyMhIGBgdovaSQiopJxzg2RFs2fPx+nTp1CUFAQDA0N8csvv+CXX37BJ598AicnJ12HR0SkFzgsRaRF+/btw8yZM3HhwgXk5ubC2dkZffv2xZQpU8r9BnEiIlLG5IaIiIj0CufcEBERkV5hckNERER6pcoN8svlcty+fRuWlpYaWzSNiIiIKpcQAg8fPkTt2rWLvWPuRVUuubl9+zafSiEiInpNpaWlvfSFqlUuubG0tARQ+OG8+GZnIiIiejXl5OTAyclJ8T1eliqX3BQNRVlZWTG5ISIies2oMqWEE4qJiIhIrzC5ISIiIr3C5IaIiIj0SpWbc0NERJohk8nw7NkzXYdBesTY2Pilj3mrgskNERGpRQiBO3fuICsrS9ehkJ4xMDCAm5sbjI2NK3QeJjdERKSWosTG1tYW1apV44KopBFFi+xmZGTA2dm5Qj9XTG6IiEhlMplMkdjUqlVL1+GQnrGxscHt27dRUFAAIyOjcp+HE4qJiEhlRXNsqlWrpuNISB8VDUfJZLIKnYfJDRERqY1DUVQZNPVzxWEpTZHJgIQEICMDcHAAAgMBqVTXUREREVU5Ou25cXV1hUQiKbaNGDGixPYxMTHF2pqammo56hLExgKurkBQEPDRR4X/dXUtLCciotfajBkz0KRJE7WOadeuHcLDw3UeR3x8PCQSSZV7sk2nPTeJiYlK42rnzp3D22+/jZ49e5Z6jJWVFS5duqTY13nXaGws0KMHIIRyeXp6YfnWrUBIiG5iIyKiChs/fjxGjRql1jGxsbEVmhCrS+3atUOTJk0QGRmp61DKTafJjY2NjdL+3LlzUbduXbRt27bUYyQSCezt7Ss7NNXIZEBYWPHEBigsk0iA8HCgWzcOURERvegVH84XQkAmk8HCwgIWFhZqHVuzZs1KiopU8cpMKM7Pz8ePP/6IQYMGldkbk5ubCxcXFzg5OaFbt244f/58mefNy8tDTk6O0qYxCQnArVul1wsBpKUVtiMion/pYDg/Ly8Po0ePhq2tLUxNTdGmTRskJiYq6ouGcH755Rc0bdoUJiYmOHToULHhoIKCAowePRrVq1dHrVq1MGnSJPTv3x/du3dXtHlxWMrV1RVz5szBoEGDYGlpCWdnZ6xatUopvkmTJqF+/fqoVq0a3N3dMXXqVLVXgN69ezfq168PMzMzBAUF4caNG0r19+/fR2hoKOrUqYNq1arBx8cHGzZsUNQPGDAABw8eRFRUlGL6x40bNyCTyTB48GC4ubnBzMwMDRo0QFRUlFqxadMrk9zs2LEDWVlZGDBgQKltGjRogO+//x7/+9//8OOPP0Iul6NVq1a4VUaCERERAWtra8Xm5OSkuaAzMjTbjoioKigazn/x3+6i4fxKSnAmTpyIbdu2Yc2aNTh9+jTq1auH4OBgPHjwQKnd559/jrlz5yI5ORmNGzcudp558+Zh3bp1iI6OxuHDh5GTk4MdO3a89PoLFy5Es2bNcObMGQwfPhyfffaZ0jQLS0tLxMTE4MKFC4iKisK3336Lr7/+WuX7S0tLQ0hICLp27YqkpCQMGTIEn3/+uVKbp0+fomnTpvj5559x7tw5fPLJJ+jbty9OnDgBAIiKikJAQACGDh2KjIwMZGRkwMnJCXK5HI6OjtiyZQsuXLiAadOm4f/+7/+wefNmlePTKvGKeOedd0SXLl3UOiY/P1/UrVtXfPHFF6W2efr0qcjOzlZsaWlpAoDIzs6uaMhCHDggRGH/TNnbgQMVvxYR0SvgyZMn4sKFC+LJkyflO0FBgRCOjqX/eymRCOHkVNhOg3Jzc4WRkZFYt26doiw/P1/Url1bzJ8/XwghxIEDBwQAsWPHDqVjp0+fLnx9fRX7dnZ2YsGCBc/dUoFwdnYW3bp1U5S1bdtWhIWFKfZdXFzExx9/rNiXy+XC1tZWLF++vNSYFyxYIJo2bVpqHC+aPHmy8Pb2ViqbNGmSACAyMzNLPa5z585i3LhxpcZemhEjRogPPvjgpe3UUdbPV3Z2tsrf36/Eo+A3b97E/v37Eatmtm5kZAQ/Pz9cvXq11DYmJiYwMTGpaIglCwwEHB0Lf9soad6NRFJYHxhYOdcnInrdqDOc366dxi577do1PHv2DK1bt1aUGRkZoXnz5khOTlZq26xZs1LPk52djbt376J58+aKMqlUiqZNm0Iul5cZw/O9QEXzR+/du6co27RpExYvXoxr164hNzcXBQUFsLKyUvkek5OT0aJFC6WygIAApX2ZTIY5c+Zg8+bNSE9PR35+PvLy8lRalHHZsmX4/vvvkZqaiidPniA/P1/tp7e05ZUYloqOjoatrS06d+6s1nEymQxnz56Fg4NDJUX2ElIpUDTm+OI8oaL9yMhXaoIcEZFOvQbD+ebm5pVy3hefnpJIJIqE6OjRo+jTpw86deqEXbt24cyZM5gyZQry8/M1GsOCBQsQFRWFSZMm4cCBA0hKSkJwcPBLr7Nx40aMHz8egwcPxt69e5GUlISBAwdqPD5N0XlyI5fLER0djf79+8PQULkjqV+/fpg8ebJi/8svv8TevXtx/fp1nD59Gh9//DFu3ryJIUOGaDvsf4WEAFu3QlbbCfFoiw3ojXi0hayOMx8DJyJ6kaq/jGr4l9a6devC2NgYhw8fVpQ9e/YMiYmJ8Pb2Vvk81tbWsLOzU5qILJPJcPr06QrFd+TIEbi4uGDKlClo1qwZPDw8cPPmTbXO4eXlpZg7U+TYsWNK+4cPH0a3bt3w8ccfw9fXF+7u7rh8+bJSG2Nj42KvPzh8+DBatWqF4cOHw8/PD/Xq1cO1a9fUik+bdD4stX//fqSmpmLQoEHF6lJTU2Fg8G/+lZmZiaFDh+LOnTuoUaMGmjZtiiNHjqj1g1kZYhGCMMn7uIV/e28cIRAFCZjaEBE9R0fD+ebm5vjss88wYcIE1KxZE87Ozpg/fz4eP36MwYMHq3WuUaNGISIiAvXq1YOnpyeWLFmCzMzMCq275uHhgdTUVGzcuBFvvvkmfv75Z2zfvl2tc3z66adYuHAhJkyYgCFDhuDUqVOIiYkpdp2tW7fiyJEjqFGjBhYtWoS7d+8qfY+6urri+PHjuHHjBiwsLFCzZk14eHhg7dq1iIuLg5ubG3744QckJibCzc2t3PdcmXTec/POO+9ACIH69esXq4uPj1f6g/n6669x8+ZN5OXl4c6dO/j555/h5+enxWiL+3fSv/IPdXq6pDIn/RMRvZ50OJw/d+5cfPDBB+jbty/8/f1x9epVxMXFoUaNGmqdZ9KkSQgNDUW/fv0QEBAACwsLBAcHV2jF/Pfeew9jxozByJEj0aRJExw5cgRTp05V6xzOzs7Ytm0bduzYAV9fX6xYsQJz5sxRavPFF1/A398fwcHBaNeuHezt7ZUeYQcKFy2USqXw9vaGjY0NUlNTMWzYMISEhKBXr15o0aIF7t+/j+HDh5f7fiubRIiSUmf9lZOTA2tra2RnZ6s1UaskMlnhsgylzY0r+gUkJYXTbohIPzx9+hQpKSlwc3Or2OtvYmMLF0F9/h9QJ6fCxOY1G86Xy+Xw8vLChx9+iFmzZuk6nNdaWT9f6nx/63xY6nWmo0n/RESvv5CQwtXbX+EViktz8+ZN7N27F23btkVeXh6WLl2KlJQUfPTRR7oOjf7B5KYCXoNJ/0REry6p9LX8zc/AwAAxMTEYP348hBBo1KgR9u/fDy8vL12HRv9gclMBOpr0T0REOuTk5KT01BW9enQ+ofh1VjTpv7QJ8hJJ4RAy1/AjIiLSHiY3FcA1/IiIiF49TG4q6J81/FCnjnK5oyPX8CMiItIFzrnRgNd40j8REZHeYXKjIa/ppH8iIiK9w2EpIiIi0itMboiIiCqBq6srIiMjFfsSiQQ7duzQehwzZsxAkyZN1DomPj4eEokEWVlZlRJTZWNyQ0REpAUZGRno2LGjSm3Lk5DoWrt27RAeHq7rMABwzg0REemITPbqP4iRn58PY2NjjZzL3t5eI+ehl2PPDRERaV1sbOGLh4OCgI8+Kvyvq2theWVp164dRo4ciZEjR8La2hpvvPEGpk6diuffH+3q6opZs2ahX79+sLKywieffAIAOHToEAIDA2FmZgYnJyeMHj0ajx49Uhx37949dO3aFWZmZnBzc8O6deuKXf/FYalbt24hNDQUNWvWhLm5OZo1a4bjx48jJiYGM2fOxB9//AGJRAKJRIKYmBgAQFZWFoYMGQIbGxtYWVnhP//5D/744w+l68ydOxd2dnawtLTE4MGD8fTp05d+Nrt370b9+vVhZmaGoKAg3LhxQ6n+/v37CA0NRZ06dVCtWjX4+Phgw4YNivoBAwbg4MGDiIqKUsR848YNyGQyDB48GG5ubjAzM0ODBg0QVbRAXGUSVUx2drYAILKzs3UdChHRa+fJkyfiwoUL4smTJ+U+x7ZtQkgkQhS+XvjfTSIp3LZt02DAz2nbtq2wsLAQYWFh4uLFi+LHH38U1apVE6tWrVK0cXFxEVZWVuK///2vuHr1qmIzNzcXX3/9tbh8+bI4fPiw8PPzEwMGDFAc17FjR+Hr6yuOHj0qTp48KVq1aiXMzMzE119/rWgDQGzfvl0IIcTDhw+Fu7u7CAwMFAkJCeLKlSti06ZN4siRI+Lx48di3LhxomHDhiIjI0NkZGSIx48fCyGE6NChg+jatatITEwUly9fFuPGjRO1atUS9+/fF0IIsWnTJmFiYiJWr14tLl68KKZMmSIsLS2Fr69vqZ9LamqqMDExEWPHjlV8LnZ2dgKAyMzMFEIIcevWLbFgwQJx5swZce3aNbF48WIhlUrF8ePHhRBCZGVliYCAADF06FBFzAUFBSI/P19MmzZNJCYmiuvXrys+802bNpUYS1k/X+p8fzO5ISIilVU0uSkoEMLRsXhi83yC4+RU2E7T2rZtK7y8vIRcLleUTZo0SXh5eSn2XVxcRPfu3ZWOGzx4sPjkk0+UyhISEoSBgYF48uSJuHTpkgAgTpw4oahPTk4WAEpNblauXCksLS0VScmLpk+fXiwhSUhIEFZWVuLp06dK5XXr1hUrV64UQggREBAghg8frlTfokWLMpObyZMnC29vb6WySZMmKSU3JencubMYN26cYr9t27YiLCys1PZFRowYIT744IMS6zSV3HBYioiItCYhAbh1q/R6IYC0tMJ2laFly5aQPPe+nICAAFy5cgUymUxR1qxZM6Vj/vjjD8TExMDCwkKxBQcHQy6XIyUlBcnJyTA0NETTpk0Vx3h6eqJ69eqlxpGUlAQ/Pz/UrFlT5dj/+OMP5ObmolatWkqxpKSk4Nq1awCA5ORktGjRQum4gICAMs+ryjEymQyzZs2Cj48PatasCQsLC8TFxSE1NfWlcS9btgxNmzaFjY0NLCwssGrVKpWOqwhOKCYiIq3JyNBsu8pgbm6utJ+bm4thw4Zh9OjRxdo6Ozvj8uXLal/DzMxM7WNyc3Ph4OCA+Pj4YnVlJVKasGDBAkRFRSEyMhI+Pj4wNzdHeHg48vPzyzxu48aNGD9+PBYuXIiAgABYWlpiwYIFOH78eKXGy+SGiIi0xsFBs+3U9eKX6rFjx+Dh4QFpGY9p+fv748KFC6hXr16J9Z6enigoKMCpU6fw5ptvAgAuXbpU5hoxjRs3xurVq/HgwYMSe2+MjY2VepOK4rhz5w4MDQ3h6upa4nm9vLxw/Phx9OvXT+key+Ll5YWffvpJqezFYw4fPoxu3brh448/BgDI5XJcvnwZ3t7eZcZ8+PBhtGrVCsOHD1eUFfUyVSYOSxERkdYEBha+WPi5kSElEgng5FTYrjKkpqZi7NixuHTpEjZs2IAlS5YgLCyszGMmTZqEI0eOYOTIkUhKSsKVK1fwv//9DyNHjgQANGjQAO+++y6GDRuG48eP49SpUxgyZEiZvTOhoaGwt7dH9+7dcfjwYVy/fh3btm3D0aNHARQ+tZWSkoKkpCT8/fffyMvLQ4cOHRAQEIDu3btj7969uHHjBo4cOYIpU6bg5MmTAICwsDB8//33iI6OxuXLlzF9+nScP3++zPv79NNPceXKFUyYMAGXLl3C+vXrFU9nFfHw8MC+fftw5MgRJCcnY9iwYbh7965SG1dXVxw/fhw3btzA33//DblcDg8PD5w8eRJxcXG4fPkypk6disTExDLj0QQmN0REpDVSKVD0JPCLCU7RfmRk5a13069fPzx58gTNmzfHiBEjEBYWpnjcuzSNGzfGwYMHcfnyZQQGBsLPzw/Tpk1D7dq1FW2io6NRu3ZttG3bFiEhIfjkk09ga2tb6jmNjY2xd+9e2NraolOnTvDx8cHcuXMVPUgffPAB3n33XQQFBcHGxgYbNmyARCLB7t278dZbb2HgwIGoX78+evfujZs3b8LOzg4A0KtXL0ydOhUTJ05E06ZNcfPmTXz22Wdl3p+zszO2bduGHTt2wNfXFytWrMCcOXOU2nzxxRfw9/dHcHAw2rVrp0jMnjd+/HhIpVJ4e3vDxsYGqampGDZsGEJCQtCrVy+0aNEC9+/fV+rFqSwSIZ57wL8KyMnJgbW1NbKzs2FlZaXrcIiIXitPnz5FSkoK3NzcYGpqWu7zxMYCYWHKk4udnAoTm5CQisdZknbt2qFJkyZKr0SgV0tZP1/qfH9zzg0REWldSAjQrdurv0IxvZ6Y3BARkU5IpUC7drqOgvQRkxsiIqoSSnqEmvQTJxQTERGRXmFyQ0RERHqFyQ0RERHpFSY3REREpFeY3BAREZFeYXJDREREeoXJDRER0SuiXbt2CA8P13UYahkwYICuQyiGyQ0REdErIjY2FrNmzaq08z99+hQDBgyAj48PDA0Ni70fqkh8fDz8/f1hYmKCevXqFXuR5quOyQ0REemETC5D/I14bDi7AfE34iGTy3Qdklry8/M1fq6aNWvC0tJSY+d9kUwmg5mZGUaPHo0OHTqU2CYlJQWdO3dGUFAQkpKSEB4ejiFDhiAuLk7R5u+//0b//v3h7OyMDRs2oF69eujZs6dGP5OKYHJDRERaF5scC9coVwStCcJHsR8haE0QXKNcEZscW2nXlMvlmD9/PurVqwcTExM4Oztj9uzZivpJkyahfv36qFatGtzd3TF16lQ8e/ZMUT9jxgw0adIEq1evLvPFoTExMahevTp27NgBDw8PmJqaIjg4GGlpaS8914vDUnl5eZg0aRKcnJwUvSjfffedov7cuXPo2LEjLCwsYGdnh759++Lvv/8u9TMwNzfH8uXLMXToUNjb25fYZsWKFXBzc8PChQvh5eWFkSNHokePHvj6668VbcaMGYNjx47hhx9+QKdOnfDtt9/C3d0dcrm81GtrE5MbIiLSqtjkWPTY3AO3cm4plafnpKPH5h6VluBMnjwZc+fOxdSpU3HhwgWsX78ednZ2inpLS0vExMTgwoULiIqKwrfffqv0hQ4AV69exbZt2xAbG4ukpKRSr/X48WPMnj0ba9euxeHDh5GVlYXevXurfa5+/fphw4YNWLx4MZKTk7Fy5UpYWFgAALKysvCf//wHfn5+OHnyJPbs2YO7d+/iww8/LN8H9I+jR48W69UJDg7G0aNHFftnzpxBv3790LZtW1hbWyMoKAjz5s2r0JviNYnvliIiIq2RyWUI2xMGAVGsTkBAAgnC94SjW4NukBpo7hXhDx8+RFRUFJYuXYr+/fsDAOrWrYs2bdoo2nzxxReK/3d1dcX48eOxceNGTJw4UVGen5+PtWvXwsbGpszrPXv2DEuXLkWLFi0AAGvWrIGXlxdOnDiB5s2bq3Suy5cvY/Pmzdi3b58i2XB3d1fUL126FH5+fpgzZ46i7Pvvv4eTkxMuX76M+vXrq/TZvOjOnTtKSR8A2NnZIScnB0+ePIGZmRlat26N6Oho+Pr6lusalY09N6QZMhkQHw9s2FD4X9nrNXZORNqRkJpQrMfmeQICaTlpSEhN0Oh1k5OTkZeXh/bt25faZtOmTWjdujXs7e1hYWGBL774AqmpqUptXFxcXprYAIChoSHefPNNxb6npyeqV6+O5ORklc+VlJQEqVSKtm3bllj/xx9/4MCBA7CwsFBsnp6eAIBr1669NMaKWLRoEXr16oUxY8Zg7dq1aNKkCVasWFGp11SHTpMbV1dXSCSSYtuIESNKPWbLli3w9PSEqakpfHx8sHv3bi1GTCWKjQVcXYGgIOCjjwr/6+paWE5E9JyMhxkabacqMzOzMuuPHj2KPn36oFOnTti1axfOnDmDKVOmFJsga25urrGYXnaul8Wcm5uLrl27IikpSWm7cuUK3nrrrXLHZW9vj7t37yqV3b17F1ZWVoqYzM3NMXv2bFy5cgXvvfcePvvsM4wdOxarVq0q93U1SafJTWJiIjIyMhTbvn37AAA9e/Yssf2RI0cQGhqKwYMH48yZM+jevTu6d++Oc+fOaTNsel5sLNCjB3Drhd/E0tMLy5ngENFzHCwdNNpOVR4eHjAzM8Ovv/5aYv2RI0fg4uKCKVOmoFmzZvDw8MDNmzfLfb2CggKcPHlSsX/p0iVkZWXBy8tL5XP4+PhALpfj4MGDJdb7+/vj/PnzcHV1Rb169ZS2iiRhAQEBxT6nffv2ISAgoMT21atXx7Bhw9CxY0ckJGi2x628dJrc2NjYwN7eXrHt2rULdevWLbULLioqCu+++y4mTJgALy8vzJo1C/7+/li6dKmWIycAhUNPYWGAKD52rigLD+cQFREpBDoHwtHKERJISqyXQAInKycEOgdq9LqmpqaYNGkSJk6ciLVr1+LatWs4duyY4skjDw8PpKamYuPGjbh27RoWL16M7du3l/t6RkZGGDVqFI4fP45Tp05hwIABaNmypWK+jSpcXV3Rv39/DBo0CDt27EBKSgri4+OxefNmAMCIESPw4MEDhIaGIjExEdeuXUNcXBwGDhwIWRn/7l64cAFJSUl48OABsrOzFT0+RT799FNcv34dEydOxMWLF/HNN99g8+bNGDNmjKLNmDFjcPDgQWRnZ0Mmk+HAgQM4ePAgmjZtqv6HVQlemTk3+fn5+PHHHzFo0CBIJCX/0Ksyg/tFeXl5yMnJUdpIQxISivfYPE8IIC2tsB0REQCpgRRR70YBQLEEp2g/8t1IjU4mLjJ16lSMGzcO06ZNg5eXF3r16oV79+4BAN577z2MGTMGI0eORJMmTXDkyBFMnTq13NeqVq0aJk2ahI8++gitW7eGhYUFNm3apPZ5li9fjh49emD48OHw9PTE0KFD8ejRIwBA7dq1cfjwYchkMrzzzjvw8fFBeHg4qlevDgOD0r/eO3XqBD8/P+zcuRPx8fHw8/ODn5+fot7NzQ0///wz9u3bB19fXyxcuBCrV69GcHCwoo2zszPGjh0LJycnrF+/Hv369cOgQYMwatQote+xUohXxKZNm4RUKhXp6emltjEyMhLr169XKlu2bJmwtbUt9Zjp06cLAMW27OxsjcVeZa1fL0RhClP29sKfGRG9vp48eSIuXLggnjx5UqHzbLuwTTguchSYAcXmtMhJbLuwTUOR6k50dLSwtrbWdRha079/f42dq6yfr+zsbJW/v1+ZR8G/++47dOzYEbVr19boeSdPnoyxY8cq9nNycuDk5KTRa1RZDv+OictggAQEIgMOcEAGApEAKeTF2hERAUCIVwi6NeiGhNQEZDzMgIOlAwKdAyulx4aqnlciubl58yb279+P2JdMPi1tBndpqywCgImJCUxMTDQSJ70gMBBwdETsreYIQyRu4d+k0RFpiEI4QpwSC9sREb1AaiBFO9d2ug6DKuhVfO/UKzHnJjo6Gra2tujcuXOZ7dSdwU2VTCpFbOgW9MAW3EIdpap01EEPbEFs782AlL+JEVHVMWDAAGRlZek6jCpN58mNXC5HdHQ0+vfvD0ND5Y6kfv36YfLkyYr9sLAw7NmzBwsXLsTFixcxY8YMnDx5EiNHjtR22IR/Hpba0BICErz4oyRgAECC8I0t+bAUERFplc6Tm/379yM1NRWDBg0qVpeamoqMjH8XcmrVqhXWr1+PVatWwdfXF1u3bsWOHTvQqFEjbYZM//j3YamSn24TkPBhKSI9JUpaAoKogjT1c6XzOTfvvPNOqTcTHx9frKxnz56lLvJH2pWh4gKiqrYjolefkZERgMIXQ75sBV0idRWtCC2t4HQGnSc39PpS9SEoPixFpD+kUimqV6+uWB+mWrVqpa5NRqQOuVyOv/76C9WqVSs2TUVdTG6o3P55WArp6SUvUiyRFNbzYSki/VL0hGpRgkOkKQYGBnB2dq5wwszkhspNKgWiogpfISWRKCc4RT+XkZF8WIpI30gkEjg4OMDW1hbPnj3TdTikR4yNjctcXVlVTG6oQkJCgK1bC18x9fybGBwdCxObkBCdhUZElUwqlVZ4bgRRZWByQxUWEgJ061b4VFRGRuEcm8BA9tgQEZFuMLkhjZBKgXbtdB0FERHRK7DODREREZEmMbkhIiIivcLkhoiIiPQKkxsiIiLSK0xuiIiISK8wuSEiIiK9wuSGiIiI9AqTGyIiItIrTG6IiIhIrzC5ISIiIr3C5IaIiIj0CpMbIiIi0itMboiIiEivMLkhIiIivcLkhoiIiPQKkxsiIiLSK0xuiIiISK8wuSEiIiK9wuSGiIiI9AqTGyIiItIrTG6IiIhIrzC5ISIiIr3C5IaIiIj0CpMbIiIi0itMboiIiEivMLkhIiIivcLkhoiIiPQKkxsiIiLSK0xuiIiISK8wuSEiIiK9wuSGiIiI9IqhrgMg0hsyGZCQAGRkAA4OQGAgIJXqOioioipH5z036enp+Pjjj1GrVi2YmZnBx8cHJ0+eLLV9fHw8JBJJse3OnTtajJroBbGxgKsrEBQEfPRR4X9dXQvLiYhIq3Tac5OZmYnWrVsjKCgIv/zyC2xsbHDlyhXUqFHjpcdeunQJVlZWin1bW9vKDJWodLGxQI8egBDK5enpheVbtwIhIbqJjYioCtJpcjNv3jw4OTkhOjpaUebm5qbSsba2tqhevXolRUakIpkMCAsrntgAhWUSCRAeDnTrxiEqIiIt0emw1E8//YRmzZqhZ8+esLW1hZ+fH7799luVjm3SpAkcHBzw9ttv4/Dhw6W2y8vLQ05OjtJGpDEJCcCtWwAAGQwQj7bYgN6IR1vIYFCY4KSlFbYjIiKt0Glyc/36dSxfvhweHh6Ii4vDZ599htGjR2PNmjWlHuPg4IAVK1Zg27Zt2LZtG5ycnNCuXTucPn26xPYRERGwtrZWbE5OTpV1O1QVZWQAAGLxPlxxA0GIx0fYgCDEwxU3EIv3ldoREVHlkwhRUn+6dhgbG6NZs2Y4cuSIomz06NFITEzE0aNHVT5P27Zt4ezsjB9++KFYXV5eHvLy8hT7OTk5cHJyQnZ2ttKcHaJyiY9HbNBi9MBWFP5F+vf3BQnkAICt6IGQA6OBdu10ESERkV7IycmBtbW1St/fOu25cXBwgLe3t1KZl5cXUlNT1TpP8+bNcfXq1RLrTExMYGVlpbQRaYqsVSDCpEuLJTYAIP7ZD5cugaxVoNZjIyKqqnSa3LRu3RqXLl1SKrt8+TJcXFzUOk9SUhIcHBw0GRqRShKOSHFLVhul/VUSMECarA4SjnAyMRGRtuj0aakxY8agVatWmDNnDj788EOcOHECq1atwqpVqxRtJk+ejPT0dKxduxYAEBkZCTc3NzRs2BBPnz7F6tWr8dtvv2Hv3r26ug2qwlSdSsMpN0RE2qPT5ObNN9/E9u3bMXnyZHz55Zdwc3NDZGQk+vTpo2iTkZGhNEyVn5+PcePGIT09HdWqVUPjxo2xf/9+BAUF6eIWqIpTtcOQHYtERNqj0oTiP//8U+UTNm7cuEIBVTZ1JiQRvYxMVrgQcXp6yUvdSCSAoyOQksJlboiIKkKd72+Vem6aNGkCiUSC0vKgojqJRAKZTKZ+xESvKakUiIoqXIhYIlFOcCSSwv9GRjKxISLSJpWSm5SUlMqOg+i1FRJS+IaFsDDFen4ACntsIiP55gUiIm3T6To3usBhKaosfCk4EVHl0fiw1E8//aTyxd977z2V2xLpE6mU6/QREb0KVEpuunfvrtLJOOeGiIiIdE2l5EYul1d2HEREREQaUaEVip8+faqpOIiIiIg0Qu3kRiaTYdasWahTpw4sLCxw/fp1AMDUqVPx3XffaTxAIiIiInWondzMnj0bMTExmD9/PoyNjRXljRo1wurVqzUaHBEREZG61E5u1q5di1WrVqFPnz6QPvecq6+vLy5evKjR4IiIiIjUpXZyk56ejnr16hUrl8vlePbsmUaCIiIiIiovtZMbb29vJCQkFCvfunUr/Pz8NBIUERERUXmp/VbwadOmoX///khPT4dcLkdsbCwuXbqEtWvXYteuXZURIxEREZHK1O656datG3bu3In9+/fD3Nwc06ZNQ3JyMnbu3Im33367MmIkIiIiUhnfLUVERESvPI2/W6o0T58+xaZNm/D48WN06NABHh4eFTkdERERUYWpnNyMHTsWz549w5IlSwAA+fn5aNmyJS5cuIBq1aphwoQJ2LdvHwICAiotWCIiIqKXUXnOzd69e5Xm1Kxbtw6pqam4cuUKMjMz0bNnT3z11VeVEiQRERGRqlROblJTU+Ht7a3Y37t3L3r06AEXFxdIJBKEhYXhzJkzlRIkERERkapUTm4MDAzw/NzjY8eOoWXLlor96tWrIzMzU7PREREREalJ5eTGy8sLO3fuBACcP38eqampCAoKUtTfvHkTdnZ2mo+QiIiISA0qTyieOHEievfujZ9//hnnz59Hp06d4ObmpqjfvXs3mjdvXilBEhEREalK5Z6b999/H7t370bjxo0xZswYbNq0Sam+WrVqGD58uMYDJCIiIlIHF/EjIiKiV546399qv36BiIiI6FXG5IaIiIj0CpMbIiIi0itqJTdCCKSmpuLp06eVFQ8RERFRhaid3NSrVw9paWmVFQ8RERFRhaiV3BgYGMDDwwP379+vrHiIiIiIKkTtOTdz587FhAkTcO7cucqIh4iIiKhC1F7npkaNGnj8+DEKCgpgbGwMMzMzpfoHDx5oNEBN4zo3RERErx91vr9Vfv1CkcjIyPLGRURERFTp1E5u+vfvXxlxEBEREWmE2snN854+fYr8/HylMg71EBERkS6pPaH40aNHGDlyJGxtbWFubo4aNWoobURERES6pHZyM3HiRPz2229Yvnw5TExMsHr1asycORO1a9fG2rVrKyNGIiIiIpWpPSy1c+dOrF27Fu3atcPAgQMRGBiIevXqwcXFBevWrUOfPn0qI04ietXJZEBCApCRATg4AIGBgFSq66iIqApSu+fmwYMHcHd3B1A4v6bo0e82bdrg999/VzuA9PR0fPzxx6hVqxbMzMzg4+ODkydPlnlMfHw8/P39YWJignr16iEmJkbt6xKRBsXGAq6uQFAQ8NFHhf91dS0sJyLSMrWTG3d3d6SkpAAAPD09sXnzZgCFPTrVq1dX61yZmZlo3bo1jIyM8Msvv+DChQtYuHBhmXN3UlJS0LlzZwQFBSEpKQnh4eEYMmQI4uLi1L0VItKE2FigRw/Ibt1GPNpiA3ojHm0hu5UB9OjBBIeItE7tRfy+/vprSKVSjB49Gvv370fXrl0hhMCzZ8+waNEihIWFqXyuzz//HIcPH0ZCQoLKx0yaNAk///yz0grJvXv3RlZWFvbs2fPS47mIH5EGyWSAqytib72JMEThFpwUVY5IQxTCEeKUCKSkcIiKiCpEne9vtZObF928eROnTp1CvXr10LhxY7WO9fb2RnBwMG7duoWDBw+iTp06GD58OIYOHVrqMW+99Rb8/f2VFhOMjo5GeHg4srOzi7XPy8tDXl6eYj8nJwdOTk5Mbog0IT4esUGL0QNbUfgPyb+dwRLIAQBb0QMhB0YD7drpIkIi0hPqJDdqD0u9yMXFBSEhIWonNgBw/fp1LF++HB4eHoiLi8Nnn32G0aNHY82aNaUec+fOHdjZ2SmV2dnZIScnB0+ePCnWPiIiAtbW1orNycmpWBsiKh9Z+h2EIapYYgMA4p/9cERCln5H67ERUdWlcnLz22+/wdvbGzk5OcXqsrOz0bBhQ7WGlwBALpfD398fc+bMgZ+fHz755BMMHToUK1asUOs8ZZk8eTKys7MVW1pamsbOTVTVJfzl+c9QVMn/lAgYIA3OSPjLU7uBEVGVpnJyExkZiaFDh5bYFWRtbY1hw4Zh0aJFal3cwcEB3t7eSmVeXl5ITU0t9Rh7e3vcvXtXqezu3buwsrIq9hJPADAxMYGVlZXSRkSakWGjWo+tqu2IiDRB5eTmjz/+wLvvvltq/TvvvINTp06pdfHWrVvj0qVLSmWXL1+Gi4tLqccEBATg119/VSrbt28fAgIC1Lo2EVWcQx3V/glRtR0RkSao/C/O3bt3YWRkVGq9oaEh/vrrL7UuPmbMGBw7dgxz5szB1atXsX79eqxatQojRoxQtJk8eTL69eun2P/0009x/fp1TJw4ERcvXsQ333yDzZs3Y8yYMWpdm4gqLjAQcHQEJCj5uQQJBJycCtsREWmLyslNnTp1lB6/ftGff/4JBwcHtS7+5ptvYvv27diwYQMaNWqEWbNmITIyUmmV44yMDKVhKjc3N/z888/Yt28ffH19sXDhQqxevRrBwcFqXZuIKk4qBaKiAEgkkEiUExyJRAASCSIj+RQ4EWmXyo+Cjxo1CvHx8UhMTISpqalS3ZMnT9C8eXMEBQVh8eLFlRKopnCdGyLNi40FwsKAW7f+LXNyAiIjgZAQnYVFRHqkUta5uXv3Lvz9/SGVSjFy5Eg0aNAAAHDx4kUsW7YMMpkMp0+fLvaY9quGyQ1R5eCrpYioMlXaIn43b97EZ599hri4OBQdJpFIEBwcjGXLlsHNza1ikWsBkxsiIqLXjzrf32q9FdzFxQW7d+9GZmYmrl69CiEEPDw8ynwXFBEREZE2qZXcFKlRowbefPNNTcdCREREVGFcfIKIiIj0CpMbIiIi0itMboiIiEivqJTc+Pv7IzMzEwDw5Zdf4vHjx5UaFBEREVF5qZTcJCcn49GjRwCAmTNnIjc3t1KDIiIiIiovlZ6WatKkCQYOHIg2bdpACIH//ve/sLCwKLHttGnTNBogERERkTpUWsTv0qVLmD59Oq5du4bTp0/D29sbhobF8yKJRILTp09XSqCawkX8iIiIXj+VtkIxABgYGODOnTuwtbWtUJC6wuSGiIjo9VNpKxQDgFwuL3dgRERERJWtXCsUX7t2DZGRkUhOTgYAeHt7IywsDHXr1tVocERERETqUnudm7i4OHh7e+PEiRNo3LgxGjdujOPHj6Nhw4bYt29fZcRIREREpDK159z4+fkhODgYc+fOVSr//PPPsXfvXk4oJiIiIo1T5/tb7Z6b5ORkDB48uFj5oEGDcOHCBXVPR0RERKRRaic3NjY2SEpKKlaelJT02j5BRURERPpD7QnFQ4cOxSeffILr16+jVatWAIDDhw9j3rx5GDt2rMYDJCIiIlKH2nNuhBCIjIzEwoULcfv2bQBA7dq1MWHCBIwePRoSiaRSAtUUzrkhIiJ6/VTqIn7Pe/jwIQDA0tKyvKfQOiY3REREr59KXcTvea9TUkNERERVg9oTiomIiIheZUxuiIiISK8wuSEiIiK9olZy8+zZM7Rv3x5XrlyprHiIiIiIKkSt5MbIyAh//vlnZcVCREREVGFqD0t9/PHH+O677yojFiIiIqIKU/tR8IKCAnz//ffYv38/mjZtCnNzc6X6RYsWaSw4IiIiInWpndycO3cO/v7+AIDLly8r1b3qqxMTERGR/lM7uTlw4EBlxEFERESkEeV+FPzq1auIi4vDkydPABS+c4qIiIhI19RObu7fv4/27dujfv366NSpEzIyMgAAgwcPxrhx4zQeIBEREZE61E5uxowZAyMjI6SmpqJatWqK8l69emHPnj0aDY6IiIhIXWrPudm7dy/i4uLg6OioVO7h4YGbN29qLDAiIiKi8lC75+bRo0dKPTZFHjx4ABMTE40ERURERFReaic3gYGBWLt2rWJfIpFALpdj/vz5CAoK0mhwREREROpSe1hq/vz5aN++PU6ePIn8/HxMnDgR58+fx4MHD3D48OHKiJGI6JUny5ch4ZuzyLj2GA51qyFwuA+kxlJdh0VUJandc9OoUSNcvnwZbdq0Qbdu3fDo0SOEhITgzJkzqFu3rlrnmjFjBiQSidLm6elZavuYmJhi7U1NTdW9BSIijYqdeAyu1e4iaEwTfLS0FYLGNIFrtbuInXhM16ERVUlq99wAgLW1NaZMmaKRABo2bIj9+/f/G5Bh2SFZWVnh0qVLin2uikxEuhQ78Rh6LGiOF1f6SpfZo8cCe2zFMYTMb6mT2IiqqnIlN5mZmfjuu++QnJwMAPD29sbAgQNRs2ZN9QMwNIS9vb3K7SUSiVrtiYgqiyxfhrBFzv8kNsod4QIGkECO8EVO6PaVjENURFqk9rDU77//DldXVyxevBiZmZnIzMzE4sWL4ebmht9//13tAK5cuYLatWvD3d0dffr0QWpqapntc3Nz4eLiAicnJ3Tr1g3nz58vs31eXh5ycnKUNiIiTUj45ixuyWqjtH9KBQyQJquDhG/OajcwoipO7eRmxIgR6NWrF1JSUhAbG4vY2Fhcv34dvXv3xogRI9Q6V4sWLRATE4M9e/Zg+fLlSElJQWBgIB4+fFhi+wYNGuD777/H//73P/z444+Qy+Vo1aoVbt26Veo1IiIiYG1trdicnJzUipGIqDQZ1x5rtB0RaYZEqPlSKDMzMyQlJaFBgwZK5ZcuXUKTJk0U75oqj6ysLLi4uGDRokUYPHjwS9s/e/YMXl5eCA0NxaxZs0psk5eXh7y8PMV+Tk4OnJyckJ2dDSsrq3LHSkQUH5mEoDFNXtruwNdJaBf+8nZEVLqcnBxYW1ur9P2tds+Nv7+/Yq7N85KTk+Hr66vu6ZRUr14d9evXx9WrV1Vqb2RkBD8/vzLbm5iYwMrKSmkjItKEwOE+cJTehgTyEuslkMNJmo7A4T5ajoyoalNpQvGff/6p+P/Ro0cjLCwMV69eRcuWhU8AHDt2DMuWLcPcuXMrFExubi6uXbuGvn37qtReJpPh7Nmz6NSpU4WuS0RUHlJjKaLGpqLHAntIIId47vfFooQncmwapMZ1dBUiUZWk0rCUgYEBJBIJXtZUIpFAJpOpfPHx48eja9eucHFxwe3btzF9+nQkJSXhwoULsLGxQb9+/VCnTh1EREQAAL788ku0bNkS9erVQ1ZWFhYsWIAdO3bg1KlT8Pb2Vuma6nRrERGpInbiMYQtcv5ncnEhJ2k6Isem8TFwIg1R5/tbpZ6blJQUjQT2olu3biE0NBT379+HjY0N2rRpg2PHjsHGxgYAkJqaCgODf38TyszMxNChQ3Hnzh3UqFEDTZs2xZEjR1RObIiIKkPI/Jbo9pUMCd8kvbBCMXtsiHRB7QnFrzv23BAREb1+NN5z86Lbt2/j0KFDuHfvHuRy5Yl0o0ePLs8piYiIiDRC7eQmJiYGw4YNg7GxMWrVqqX0+gOJRMLkhoiIiHRK7WEpJycnfPrpp5g8ebLSfJjXBYeliIiIXj+Vus7N48eP0bt379cysSEiIiL9p3aGMnjwYGzZsqUyYiEiIiKqMLWHpWQyGbp06YInT57Ax8cHRkZGSvWLFi3SaICaxmEpIiKi10+lPi0VERGBuLg4xbulXpxQTERERKRLaic3CxcuxPfff48BAwZUQjhEREREFaP2nBsTExO0bt26MmIhIiIiqjC1k5uwsDAsWbKkMmIhIiIiqjC1h6VOnDiB3377Dbt27ULDhg2LTSiOjY3VWHBERERE6lI7ualevTpCQkIqIxYiIiKiClM7uYmOjq6MOIiIiIg0gssMExERkV5Ru+fGzc2tzPVsrl+/XqGAiIiIiCpC7eQmPDxcaf/Zs2c4c+YM9uzZgwkTJmgqLiIiIqJyUTu5CQsLK7F82bJlOHnyZIUDIiIiIqoIjc256dixI7Zt26ap0xERERGVi8aSm61bt6JmzZqaOh0RERFRuag9LOXn56c0oVgIgTt37uCvv/7CN998o9HgiIiIiNSldnLTvXt3pX0DAwPY2NigXbt28PT01FRcREREROUiEUIIXQehTTk5ObC2tkZ2djasrKx0HQ4RERGpQJ3vby7iR0RERHpF5WEpAwODMhfvAwCJRIKCgoIKB0VERERUXionN9u3by+17ujRo1i8eDHkcrlGgiIiIiIqL5WTm27duhUru3TpEj7//HPs3LkTffr0wZdffqnR4IiIiIjUVa45N7dv38bQoUPh4+ODgoICJCUlYc2aNXBxcdF0fERERERqUSu5yc7OxqRJk1CvXj2cP38ev/76K3bu3IlGjRpVVnxEREREalF5WGr+/PmYN28e7O3tsWHDhhKHqYiIiIh0TeV1bgwMDGBmZoYOHTpAKpWW2i42NlZjwVUGrnNDRET0+lHn+1vlnpt+/fq99FFwIiIiIl1TObmJiYmpxDCIiIiINIMrFBMREZFeYXJDREREekXtt4ITERGVRCYDEhKAjAzAwQEIDATKeP6EqNIwuSEiogqLjQXCwoBbt/4tc3QEoqKAkBDdxUVVE4eliIioQmJjgR49lBMbAEhPLyx/xVcIIT3E5IaIiMpNJivssSlpxbSisvDwwnZE2qLT5GbGjBmQSCRKm6enZ5nHbNmyBZ6enjA1NYWPjw92796tpWiJiOhFCQnFe2yeJwSQllbYjkhbdN5z07BhQ2RkZCi2Q4cOldr2yJEjCA0NxeDBg3HmzBl0794d3bt3x7lz57QYMRERFcnI0Gw7Ik3QeXJjaGgIe3t7xfbGG2+U2jYqKgrvvvsuJkyYAC8vL8yaNQv+/v5YunSpFiMmIqIiDg6abUekCTpPbq5cuYLatWvD3d0dffr0QWpqaqltjx49ig4dOiiVBQcH4+jRo5UdJhERlSCwlQyO0tuQQF5ivQRyOEnTEdiKk25Ie3Sa3LRo0QIxMTHYs2cPli9fjpSUFAQGBuLhw4cltr9z5w7s7OyUyuzs7HDnzp1Sr5GXl4ecnByljYiINEN6JAFRspEAUCzBKdqPlI2C9Agn3ZD26DS56dixI3r27InGjRsjODgYu3fvRlZWFjZv3qyxa0RERMDa2lqxOTk5aezcRERVXkYGQrAdW9EDdZCuVOWIW9iKHgjBdk66Ia3S+bDU86pXr4769evj6tWrJdbb29vj7t27SmV3796Fvb19qeecPHkysrOzFVtaWppGYyYiqtL+mUwTgu24AVccQDusRygOoB1S4FaY2DzXjkgbXqnkJjc3F9euXYNDKX8JAgIC8OuvvyqV7du3DwEBAaWe08TEBFZWVkobERFpSGBg4VLEEgmkkKMdDiIUG9EOByGFHJBIACenwnZEWqLT5Gb8+PE4ePAgbty4gSNHjuD999+HVCpFaGgoAKBfv36YPHmyon1YWBj27NmDhQsX4uLFi5gxYwZOnjyJkSNH6uoWiIiqNqm08B0LQGEi87yi/chIvmSKtEqnyc2tW7cQGhqKBg0a4MMPP0StWrVw7Ngx2NjYAABSU1OR8dw4batWrbB+/XqsWrUKvr6+2Lp1K3bs2IFGjRrp6haIiCgkBNi6FahTR7nc0bGwnC+XIi2TCFHSotn6KycnB9bW1sjOzuYQFRGRJvG14FSJ1Pn+5lvBiYhIM6RSoF07XUdB9GpNKCYiIiKqKCY3REREpFeY3BAREZFeYXJDREREeoXJDREREekVJjdERESkV5jcEBERkV5hckNERER6hckNERER6RUmN0RERKRXmNwQERGRXmFyQ0RERHqFyQ0RERHpFSY3REREpFeY3BAREZFeYXJDREREeoXJDREREekVJjdERESkV5jcEBERkV5hckNERER6hckNERER6RUmN0RERKRXmNwQERGRXmFyQ0RERHqFyQ0RERHpFSY3REREpFeY3BAREZFeYXJDREREeoXJDREREekVJjdERESkV5jcEBERkV4x1HUARERE+kAmAxISgIwMwMEBCAwEpFJdR1U1MbkhIiKqoNhYICwMuHXr3zJHRyAqCggJ0V1cVRWHpYiIiCogNhbo0UM5sQGA9PTC8thY3cRVlTG5ISIiKieZrLDHRojidUVl4eGF7Uh7mNwQERGVU0JC8R6b5wkBpKUVtiPtYXJDRERUThkZmm1HmvHKJDdz586FRCJBeHh4qW1iYmIgkUiUNlNTU+0FSURE9BwHB822I814JZ6WSkxMxMqVK9G4ceOXtrWyssKlS5cU+xKJpDJDIyIiKlVgYOFTUem3BASKfx9JIODoJEFgoA6Cq8J03nOTm5uLPn364Ntvv0WNGjVe2l4ikcDe3l6x2dnZaSFKIiKi4qRSICr0GAABCeRKdYX7ApG9j3G9Gy3TeXIzYsQIdO7cGR06dFCpfW5uLlxcXODk5IRu3brh/PnzlRwhERFRKWQyhGzoia3ogTpIV6pyxC1sRU+EbPyQj0tpmU6HpTZu3IjTp08jMTFRpfYNGjTA999/j8aNGyM7Oxv//e9/0apVK5w/fx6Ojo4lHpOXl4e8vDzFfk5OjkZiJyIiKnpcKgS30A3/QwICkQEHOCADgUiAFHIg7Z927drpOtoqQ2fJTVpaGsLCwrBv3z6VJwUHBAQgICBAsd+qVSt4eXlh5cqVmDVrVonHREREYObMmRqJmYiISMlzj0FJIUc7HHxpO6p8OhuWOnXqFO7duwd/f38YGhrC0NAQBw8exOLFi2FoaAiZCl14RkZG8PPzw9WrV0ttM3nyZGRnZyu2tLQ0Td4GERFVZXxc6pWks56b9u3b4+zZs0plAwcOhKenJyZNmgSpCrOvZDIZzp49i06dOpXaxsTEBCYmJhWOl4iIqBjF41LpJS9TLJEU1vNxKa3SWXJjaWmJRo0aKZWZm5ujVq1aivJ+/fqhTp06iIiIAAB8+eWXaNmyJerVq4esrCwsWLAAN2/exJAhQ7QePxERUeHjUlGFL5GSSJQTnKKlSiIj+XpwLdP501JlSU1NRcZz45SZmZkYOnQovLy80KlTJ+Tk5ODIkSPw9vbWYZRERFSlhYQAW7cCdeoolzs6FpbzteBaJxGipH40/ZWTkwNra2tkZ2fDyspK1+EQEZG+kMkKn4rKyCicYxMYyB4bDVLn+/uVWKGYiIjotSeV8nHvV8QrPSxFREREpC4mN0RERKRXmNwQERGRXmFyQ0RERHqFyQ0RERHpFSY3REREpFeY3BAREZFeYXJDREREeoXJDREREekVJjdERESkV5jcEBERkV5hckNERER6hckNERER6RUmN0RERKRXmNwQERGRXmFyQ0RERHqFyQ0RERHpFSY3REREpFeY3BAREZFeYXJDREREeoXJDREREekVJjdERESkV5jcEBERkV5hckNERER6hckNERER6RUmN0RERKRXmNwQERGRXmFyQ0RERHqFyQ0RERHpFUNdB0BERET6QSaXISE1ARkPM+Bg6YBA50BIDaRaj4PJDREREVVYbHIswvaE4VbOLUWZo5Ujot6NQohXiFZj4bAUERERVUhscix6bO6hlNgAQHpOOnps7oHY5FitxsPkhoiIiMpNJpchbE8YBESxuqKy8D3hkMllWouJyQ0RERGVW0JqQrEem+cJCKTlpCEhNUFrMTG5ISIionLLeJih0XaawOSGiIiIys3B0kGj7TSByQ0RERGVW6BzIBytHCGBpMR6CSRwsnJCoHOg1mJickNERETlJjWQIurdKAAoluAU7Ue+G6nV9W5emeRm7ty5kEgkCA8PL7Pdli1b4OnpCVNTU/j4+GD37t3aCZCIiIhKFOIVgq0fbkUdqzpK5Y5Wjtj64Vatr3PzSizil5iYiJUrV6Jx48Zltjty5AhCQ0MRERGBLl26YP369ejevTtOnz6NRo0aaSlaIiIielGIVwi6Nej2SqxQLBFCFH8wXYtyc3Ph7++Pb775Bl999RWaNGmCyMjIEtv26tULjx49wq5duxRlLVu2RJMmTbBixQqVrpeTkwNra2tkZ2fDyspKE7dARERElUyd72+dD0uNGDECnTt3RocOHV7a9ujRo8XaBQcH4+jRo6Uek5eXh5ycHKWNiIiI9JdOh6U2btyI06dPIzExUaX2d+7cgZ2dnVKZnZ0d7ty5U+oxERERmDlzZoXiJCIioteHznpu0tLSEBYWhnXr1sHU1LTSrjN58mRkZ2crtrS0tEq7FhEREemeznpuTp06hXv37sHf319RJpPJ8Pvvv2Pp0qXIy8uDVKo8Ccne3h53795VKrt79y7s7e1LvY6JiQlMTEw0GzwRERG9snTWc9O+fXucPXsWSUlJiq1Zs2bo06cPkpKSiiU2ABAQEIBff/1VqWzfvn0ICAjQVthERET0itNZz42lpWWxx7fNzc1Rq1YtRXm/fv1Qp04dREREAADCwsLQtm1bLFy4EJ07d8bGjRtx8uRJrFq1SuvxExER0atJ509LlSU1NRUZGf++aKtVq1ZYv349Vq1aBV9fX2zduhU7duzgGjdERESkoPN1brSN69wQERG9fl6rdW6IiIiINOmVeP2CNhV1VHExPyIiotdH0fe2KgNOVS65efjwIQDAyclJx5EQERGRuh4+fAhra+sy21S5OTdyuRy3b9+GpaUlJBLJyw9QQ05ODpycnJCWllYl5/NU9fsH+Bnw/qv2/QP8DKr6/QOV9xkIIfDw4UPUrl0bBgZlz6qpcj03BgYGcHR0rNRrWFlZVdkfaoD3D/Az4P1X7fsH+BlU9fsHKuczeFmPTRFOKCYiIiK9wuSGiIiI9AqTGw0yMTHB9OnTq+y7rKr6/QP8DHj/Vfv+AX4GVf3+gVfjM6hyE4qJiIhIv7HnhoiIiPQKkxsiIiLSK0xuiIiISK8wuSEiIiK9wuRGA5YvX47GjRsrFiwKCAjAL7/8ouuwdGbu3LmQSCQIDw/XdShaMWPGDEgkEqXN09NT12FpXXp6Oj7++GPUqlULZmZm8PHxwcmTJ3Udlla4uroW+xmQSCQYMWKErkPTCplMhqlTp8LNzQ1mZmaoW7cuZs2apdI7gPTJw4cPER4eDhcXF5iZmaFVq1ZITEzUdViV4vfff0fXrl1Ru3ZtSCQS7NixQ6leCIFp06bBwcEBZmZm6NChA65cuaK1+JjcaICjoyPmzp2LU6dO4eTJk/jPf/6Dbt264fz587oOTesSExOxcuVKNG7cWNehaFXDhg2RkZGh2A4dOqTrkLQqMzMTrVu3hpGREX755RdcuHABCxcuRI0aNXQdmlYkJiYq/fnv27cPANCzZ08dR6Yd8+bNw/Lly7F06VIkJydj3rx5mD9/PpYsWaLr0LRqyJAh2LdvH3744QecPXsW77zzDjp06ID09HRdh6Zxjx49gq+vL5YtW1Zi/fz587F48WKsWLECx48fh7m5OYKDg/H06VPtBCioUtSoUUOsXr1a12Fo1cOHD4WHh4fYt2+faNu2rQgLC9N1SFoxffp04evrq+swdGrSpEmiTZs2ug7jlREWFibq1q0r5HK5rkPRis6dO4tBgwYplYWEhIg+ffroKCLte/z4sZBKpWLXrl1K5f7+/mLKlCk6iko7AIjt27cr9uVyubC3txcLFixQlGVlZQkTExOxYcMGrcTEnhsNk8lk2LhxIx49eoSAgABdh6NVI0aMQOfOndGhQwddh6J1V65cQe3ateHu7o4+ffogNTVV1yFp1U8//YRmzZqhZ8+esLW1hZ+fH7799ltdh6UT+fn5+PHHHzFo0CCNv5z3VdWqVSv8+uuvuHz5MgDgjz/+wKFDh9CxY0cdR6Y9BQUFkMlkMDU1VSo3MzOrcj25KSkpuHPnjtJ3gbW1NVq0aIGjR49qJYYq9+LMynL27FkEBATg6dOnsLCwwPbt2+Ht7a3rsLRm48aNOH36tN6OL5elRYsWiImJQYMGDZCRkYGZM2ciMDAQ586dg6Wlpa7D04rr169j+fLlGDt2LP7v//4PiYmJGD16NIyNjdG/f39dh6dVO3bsQFZWFgYMGKDrULTm888/R05ODjw9PSGVSiGTyTB79mz06dNH16FpjaWlJQICAjBr1ix4eXnBzs4OGzZswNGjR1GvXj1dh6dVd+7cAQDY2dkpldvZ2SnqKhuTGw1p0KABkpKSkJ2dja1bt6J///44ePBglUhw0tLSEBYWhn379hX7raUqeP6308aNG6NFixZwcXHB5s2bMXjwYB1Gpj1yuRzNmjXDnDlzAAB+fn44d+4cVqxYUeWSm++++w4dO3ZE7dq1dR2K1mzevBnr1q3D+vXr0bBhQyQlJSE8PBy1a9euUn/+P/zwAwYNGoQ6depAKpXC398foaGhOHXqlK5Dq3I4LKUhxsbGqFevHpo2bYqIiAj4+voiKipK12FpxalTp3Dv3j34+/vD0NAQhoaGOHjwIBYvXgxDQ0PIZDJdh6hV1atXR/369XH16lVdh6I1Dg4OxRJ5Ly+vKjc8d/PmTezfvx9DhgzRdShaNWHCBHz++efo3bs3fHx80LdvX4wZMwYRERG6Dk2r6tati4MHDyI3NxdpaWk4ceIEnj17Bnd3d12HplX29vYAgLt37yqV3717V1FX2ZjcVBK5XI68vDxdh6EV7du3x9mzZ5GUlKTYmjVrhj59+iApKQlSqVTXIWpVbm4url27BgcHB12HojWtW7fGpUuXlMouX74MFxcXHUWkG9HR0bC1tUXnzp11HYpWPX78GAYGyl8nUqkUcrlcRxHplrm5ORwcHJCZmYm4uDh069ZN1yFplZubG+zt7fHrr78qynJycnD8+HGtzUXlsJQGTJ48GR07doSzszMePnyI9evXIz4+HnFxcboOTSssLS3RqFEjpTJzc3PUqlWrWLk+Gj9+PLp27QoXFxfcvn0b06dPh1QqRWhoqK5D05oxY8agVatWmDNnDj788EOcOHECq1atwqpVq3QdmtbI5XJER0ejf//+MDSsWv+0du3aFbNnz4azszMaNmyIM2fOYNGiRRg0aJCuQ9OquLg4CCHQoEEDXL16FRMmTICnpycGDhyo69A0Ljc3V6l3OiUlBUlJSahZsyacnZ0RHh6Or776Ch4eHnBzc8PUqVNRu3ZtdO/eXTsBauWZLD03aNAg4eLiIoyNjYWNjY1o37692Lt3r67D0qmq9Ch4r169hIODgzA2NhZ16tQRvXr1ElevXtV1WFq3c+dO0ahRI2FiYiI8PT3FqlWrdB2SVsXFxQkA4tKlS7oORetycnJEWFiYcHZ2FqampsLd3V1MmTJF5OXl6To0rdq0aZNwd3cXxsbGwt7eXowYMUJkZWXpOqxKceDAAQGg2Na/f38hROHj4FOnThV2dnbCxMREtG/fXqt/NyRCVLElJImIiEivcc4NERER6RUmN0RERKRXmNwQERGRXmFyQ0RERHqFyQ0RERHpFSY3REREpFeY3BAREZFeYXJDRHovJiYG1atX18q14uPjERMTo5VrEVHJmNwQUYXcuXMHo0aNgru7O0xMTODk5ISuXbsqvVdGU27cuAGJRKLYatWqhXfeeQdnzpwp87hevXrh8uXLGo+HiF5NTG6IqNxu3LiBpk2b4rfffsOCBQtw9uxZ7NmzB0FBQRgxYkS5zyuTycp86eL+/fuRkZGBuLg45ObmomPHjsjKyiqx7bNnz2BmZgZbW9tyx6OKpKQkvP322/jggw8watQo+Pj4YMaMGZV6TSIqGZMbIiq34cOHQyKR4MSJE/jggw9Qv359NGzYEGPHjsWxY8cU7RYtWgQfHx+Ym5vDyckJw4cPR25urqK+aNjop59+gre3N0xMTJCamlrqdWvVqgV7e3s0a9YM//3vf3H37l0cP35c0bOzadMmtG3bFqampli3bl2Jw1I7d+7Em2++CVNTU7zxxht4//33FXV5eXkYP3486tSpA3Nzc7Ro0QLx8fGlxiOEQLdu3WBmZoaIiAhMnDgRc+bMgZmZmfofKhFVGJMbIiqXBw8eYM+ePRgxYgTMzc2L1T+fTBgYGGDx4sU4f/481qxZg99++w0TJ05Uav/48WPMmzcPq1evxvnz51XuaSlKIPLz8xVln3/+OcLCwpCcnIzg4OBix/z88894//330alTJ5w5cwa//vormjdvrqgfOXIkjh49io0bN+LPP/9Ez5498e677+LKlSslxnD//n2kpqZi0qRJqF+/vmJobtKkSSrdAxFpmNZe0UlEeuX48eMCgIiNjVX72C1btohatWop9qOjowUAkZSUVOZxKSkpAoA4c+aMEEKIzMxM8f777wsLCwtx584dRX1kZKTScdHR0cLa2lqxHxAQIPr06VPiNW7evCmkUqlIT09XKm/fvr2YPHlyqbE1aNBABAcHi6+//lpER0eXeR9EVLnYc0NE5SKEULnt/v370b59e9SpUweWlpbo27cv7t+/j8ePHyvaGBsbo3Hjxiqdr1WrVrCwsECNGjXwxx9/YNOmTbCzs1PUN2vWrMzjk5KS0L59+xLrzp49C5lMhvr168PCwkKxHTx4ENeuXSv1nHFxcbCzs8OcOXPw6aefon379vjtt99Uuh8i0ixDXQdARK8nDw8PSCQSXLx4scx2N27cQJcuXfDZZ59h9uzZqFmzJg4dOoTBgwcjPz8f1apVA1A4vCSRSFS69qZNm+Dt7Y1atWqV+Ih3ScNkzytrLkxubi6kUilOnToFqVSqVGdhYVHqcS4uLlizZg3i4+Nx4MAB5Obm4t1338WZM2fQsGHDsm+IiDSKPTdEVC41a9ZEcHAwli1bhkePHhWrL3p66dSpU5DL5Vi4cCFatmyJ+vXr4/bt2xW6tpOTE+rWrVvutWsaN25c6qPqfn5+kMlkuHfvHurVq6e02dvbq3R+Nzc3LFy4EJaWlkoTq4lIO5jcEFG5LVu2DDKZDM2bN8e2bdtw5coVJCcnY/HixQgICAAA1KtXD8+ePcOSJUtw/fp1/PDDD1ixYoVO454+fTo2bNiA6dOnIzk5GWfPnsW8efMAAPXr10efPn3Qr18/xMbGIiUlBSdOnEBERAR+/vnnEs93+/ZtjB07Fn/++Sfy8vLw+PFjrFy5EllZWfDz89PmrREROCxFRBXg7u6O06dPY/bs2Rg3bhwyMjJgY2ODpk2bYvny5QAAX19fLFq0CPPmzcPkyZPx1ltvISIiAv369dNZ3O3atcOWLVswa9YszJ07F1ZWVnjrrbcU9dHR0fjqq68wbtw4pKen44033kDLli3RpUuXEs9nZWWFgoIC9OjRA6mpqRBCwN3dHdHR0fD399fWbRHRPyRCnVmBRERUpvj4eNy4cQMDBgzQdShEVRaHpYiIiEivsOeGiIiI9Ap7boiIiEivMLkhIiIivcLkhoiIiPQKkxsiIiLSK0xuiIiISK8wuSEiIiK9wuSGiIiI9AqTGyIiItIrTG6IiIhIrzC5ISIiIr3y/3iYq6IdBYgDAAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# car price 예측\n",
+    "predicted = model(car_price_tensor).data.numpy()\n",
+    "plt.scatter(car_prices_array,number_of_car_sell_array,label = \"original data\",color =\"red\") # original data\n",
+    "plt.scatter(car_prices_array,predicted,label = \"predicted data\",color =\"blue\") # predicted data\n",
+    "\n",
+    "# car price가 10$ 일 때, car sell은?\n",
+    "predicted_10 = model(Variable(torch.from_numpy(np.array([[10]],dtype=np.float32)))).data.numpy()\n",
+    "plt.scatter(10,predicted_10,label = \"car price 10$\",color =\"green\")\n",
+    "plt.legend()\n",
+    "plt.xlabel(\"Car Price $\")\n",
+    "plt.ylabel(\"Number of Car Sell\")\n",
+    "plt.title(\"Original vs Predicted values\")\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "7uXrwVTU9VFH"
+   },
+   "source": [
+    "<a id=\"3\"></a> <br>\n",
+    "## 3. 로지스틱 회귀\n",
+    "\n",
+    "- 선형 회귀는 분류 문제에서 적합하지 않습니다.\n",
+    "- 우리는 분류 문제를 해결하기 위해 로지스틱 회귀를 사용합니다.\n",
+    "- 선형 회귀 + 로지스틱 함수(소프트맥스) = 로지스틱 회귀\n",
+    "\n",
+    "  \n",
+    "- **로지스틱 회귀의 단계**\n",
+    "    1. 라이브러리 가져오기\n",
+    "    2. 데이터셋 준비\n",
+    "        - 우리는 MNIST 데이터셋을 사용합니다.\n",
+    "        - 28x28 이미지와 0부터 9까지의 10개의 레이블이 있습니다.\n",
+    "        - 데이터는 정규화되지 않았기 때문에 각 이미지를 255로 나눠 기본적인 정규화를 진행합니다.\n",
+    "        - 데이터를 분할하기 위해 sklearn 라이브러리의 `train_test_split` 메서드를 사용합니다.\n",
+    "        - 학습 데이터 크기는 80%, 테스트 데이터 크기는 20%입니다.\n",
+    "        - 특성(feature)과 목표(target) 텐서를 생성합니다. 이후 텐서에서 변수(variable)를 생성합니다. 이 변수는 기울기 누적을 위해 정의됩니다.\n",
+    "        - `batch_size` = 배치 크기는 예를 들어, 1000개의 샘플이 있을 때, 이 샘플을 한 번에 모두 훈련시킬 수도 있고, 100개의 샘플씩 10개의 그룹으로 나누어 순차적으로 훈련시킬 수도 있습니다. 예를 들어, `batch_size = 100`이라면, 모든 데이터를 한 번 훈련시키는 데 336개의 그룹을 사용합니다. 각 그룹은 100개의 샘플을 가지고 있으며, 총 33600개의 샘플을 훈련합니다.\n",
+    "        - `epoch`: 1 epoch는 모든 샘플을 한 번 훈련시키는 것입니다.\n",
+    "        - 예를 들어, 33600개의 샘플이 있고, 배치 크기(batch_size)는 100, epoch는 29로 설정한 경우, 29번 훈련을 진행합니다. 그럼 총 몇 번의 반복(iteration)이 필요한지 계산해 봅시다:\n",
+    "            - 훈련 데이터 1번 = 33600개의 샘플 훈련\n",
+    "            - 하지만 데이터를 336개의 그룹으로 나누었으므로, 1 epoch는 336번의 반복이 필요합니다.\n",
+    "            - 29 epoch 동안 훈련하므로, 총 반복 횟수는 9744번입니다(대략 10000번).\n",
+    "        - `TensorDataset()`: 텐서를 래핑하는 데이터셋. 각 샘플은 텐서를 첫 번째 차원으로 인덱싱하여 검색됩니다.\n",
+    "        - `DataLoader()`: 데이터셋과 샘플을 결합하고, 데이터셋에 대한 다중 프로세스 반복기를 제공합니다.\n",
+    "        - 데이터셋의 이미지를 하나 시각화해봅니다.\n",
+    "    3. 로지스틱 회귀 모델 생성\n",
+    "        - 선형 회귀와 비슷합니다.\n",
+    "        - 하지만 예측을 위해 모델에 로지스틱 함수(소프트맥스)가 포함되어야 합니다.\n",
+    "        - PyTorch에서는 로지스틱 함수가 손실 함수에 포함되어 있으며, 이후 단계에서 이를 사용합니다.\n",
+    "    4. 모델 인스턴스화\n",
+    "        - `input_dim = 28*28` # 이미지 크기 px*px\n",
+    "        - `output_dim = 10`  # 레이블 0,1,2,3,4,5,6,7,8,9\n",
+    "        - 모델을 생성합니다.\n",
+    "    5. 손실 함수 인스턴스화\n",
+    "        - 교차 엔트로피 손실\n",
+    "        - 손실을 계산하는 함수로, 소프트맥스(로지스틱 함수)도 포함되어 있습니다.\n",
+    "    6. 옵티마이저 인스턴스화\n",
+    "        - SGD 옵티마이저\n",
+    "    7. 모델 훈련\n",
+    "    8. 예측\n",
+    "- 결과적으로, 그래프에서 볼 수 있듯이 손실 값은 감소하고, 정확도는 약 85%까지 증가하며 모델이 훈련되고 있음을 확인할 수 있습니다."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-09-14T14:41:18.495703Z",
+     "iopub.status.busy": "2026-09-14T14:41:18.495001Z",
+     "iopub.status.idle": "2026-09-14T14:41:19.969144Z",
+     "shell.execute_reply": "2026-09-14T14:41:19.967954Z"
+    },
+    "id": "FvnI_38-8CfS"
+   },
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "from torch.autograd import Variable\n",
+    "from torch.utils.data import TensorDataset, DataLoader\n",
+    "import pandas as pd\n",
+    "from sklearn.model_selection import train_test_split\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 428
+    },
+    "execution": {
+     "iopub.execute_input": "2026-09-14T14:41:19.972094Z",
+     "iopub.status.busy": "2026-09-14T14:41:19.971217Z",
+     "iopub.status.idle": "2026-09-14T14:41:24.746107Z",
+     "shell.execute_reply": "2026-09-14T14:41:24.745112Z"
+    },
+    "id": "cPmM5DM48Cb6",
+    "outputId": "79c51187-c401-448b-f29f-44886d11cde6"
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# 데이터셋 준비\n",
+    "# 데이터 로드\n",
+    "train = pd.read_csv(r\"./train.csv\", dtype=np.float32)\n",
+    "\n",
+    "# 데이터를 특징(픽셀 값)과 라벨(0~9 숫자)로 분리\n",
+    "targets_numpy = train.label.values\n",
+    "features_numpy = train.loc[:, train.columns != \"label\"].values / 255  # 정규화\n",
+    "\n",
+    "# 학습 데이터 80%, 테스트 데이터 20%로 분할\n",
+    "features_train, features_test, targets_train, targets_test = train_test_split(\n",
+    "    features_numpy, targets_numpy, test_size=0.2, random_state=42\n",
+    ")\n",
+    "\n",
+    "# 학습 데이터셋을 텐서로 변환 (경사 계산을 위해 Variable 생성 필요)\n",
+    "featuresTrain = torch.from_numpy(features_train)\n",
+    "targetsTrain = torch.from_numpy(targets_train).type(torch.LongTensor)  # 데이터 타입은 long\n",
+    "\n",
+    "# 테스트 데이터셋을 텐서로 변환\n",
+    "featuresTest = torch.from_numpy(features_test)\n",
+    "targetsTest = torch.from_numpy(targets_test).type(torch.LongTensor)  # 데이터 타입은 long\n",
+    "## 힌트: PyTorch Tesnor를 생성해주세요!\n",
+    "## 어떤 데이터를 PyTorch Tensor를 변환하고, 어떤 데이터타입을 선택할지 직접 작성해주세요\n",
+    "\n",
+    "# 배치 크기, 반복 횟수 및 에포크 설정\n",
+    "batch_size = 100\n",
+    "n_iters = 10000\n",
+    "num_epochs = int(n_iters / (len(features_train) / batch_size))\n",
+    "\n",
+    "# PyTorch 학습 및 테스트 데이터셋 생성\n",
+    "train = TensorDataset(featuresTrain, targetsTrain)\n",
+    "test = TensorDataset(featuresTest, targetsTest)\n",
+    "## 힌트: 입력 데이터와 레이블을 텐서로 변환하여, 이들을 TensorDataset으로 묶어 train과 test 데이터셋을 구성합니다\n",
+    "## TensorDataset에는 두 개의 텐서를 전달해야 하며, 각각 특징과 레이블에 해당합니다.\n",
+    "## 첫 번째 텐서는 입력 데이터, 두 번째 텐서는 정답 데이터이며 입력 데이터와 정답 데이터의 샘플 수가 동일해야 합니다.\n",
+    "\n",
+    "# 데이터 로더 생성\n",
+    "train_loader = DataLoader(train, batch_size=batch_size, shuffle=False)\n",
+    "test_loader = DataLoader(test, batch_size=batch_size, shuffle=False)\n",
+    "\n",
+    "# 데이터셋 중 하나의 이미지를 시각화\n",
+    "plt.imshow(features_numpy[10].reshape(28, 28))\n",
+    "plt.axis(\"off\")\n",
+    "plt.title(str(targets_numpy[10]))\n",
+    "plt.savefig('graph.png')\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-09-14T14:41:24.748009Z",
+     "iopub.status.busy": "2026-09-14T14:41:24.747834Z",
+     "iopub.status.idle": "2026-09-14T14:41:24.753575Z",
+     "shell.execute_reply": "2026-09-14T14:41:24.752579Z"
+    },
+    "id": "S73aSJuz8CZq"
+   },
+   "outputs": [],
+   "source": [
+    "# 로지스틱 회귀 모델 생성\n",
+    "class LogisticRegressionModel(nn.Module):\n",
+    "    def __init__(self, input_dim, output_dim):\n",
+    "        super(LogisticRegressionModel, self).__init__()\n",
+    "        # 선형 계층 설정\n",
+    "        self.linear = nn.Linear(input_dim, output_dim)\n",
+    "        # 로지스틱 함수는 손실 함수에 포함되어 있으므로 별도로 정의할 필요 없음\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        out = self.linear(x)\n",
+    "        return out\n",
+    "\n",
+    "# 모델 인스턴스화\n",
+    "input_dim = 28 * 28  # 이미지 크기 (픽셀 * 픽셀)\n",
+    "output_dim = 10  # 출력 라벨 (0~9)\n",
+    "\n",
+    "# 로지스틱 회귀 모델 생성\n",
+    "model = LogisticRegressionModel(input_dim, output_dim)\n",
+    "\n",
+    "# 크로스 엔트로피 손실 함수\n",
+    "error = nn.CrossEntropyLoss()\n",
+    "\n",
+    "# SGD 옵티마이저 설정\n",
+    "learning_rate = 0.001\n",
+    "optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)\n",
+    "## 힌트: 모델 파라미터를 model.parameters()로 넘겨줍니다\n",
+    "## 학습률(learning rate)은 훈련 속도를 결정합니다\n",
+    "## 최적화 함수가 SGD이므로, torch.optim.SGD를 사용합니다\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "execution": {
+     "iopub.execute_input": "2026-09-14T14:41:24.756563Z",
+     "iopub.status.busy": "2026-09-14T14:41:24.755582Z",
+     "iopub.status.idle": "2026-09-14T14:41:42.383576Z",
+     "shell.execute_reply": "2026-09-14T14:41:42.382292Z"
+    },
+    "id": "Oc4X8eZt8CXq",
+    "outputId": "25682b12-5d39-41b8-e09a-a722e5b22b06"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iteration: 500  Loss: 1.8559330701828003  Accuracy: 68.08333587646484%\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iteration: 1000  Loss: 1.6255323886871338  Accuracy: 76.26190185546875%\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iteration: 1500  Loss: 1.2909692525863647  Accuracy: 78.80952453613281%\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iteration: 2000  Loss: 1.1958333253860474  Accuracy: 80.20237731933594%\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iteration: 2500  Loss: 1.039230465888977  Accuracy: 81.30952453613281%\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iteration: 3000  Loss: 0.9383436441421509  Accuracy: 82.11904907226562%\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iteration: 3500  Loss: 0.9003562927246094  Accuracy: 82.73809814453125%\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iteration: 4000  Loss: 0.751753032207489  Accuracy: 83.25%\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iteration: 4500  Loss: 0.9685394167900085  Accuracy: 83.67857360839844%\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iteration: 5000  Loss: 0.8048398494720459  Accuracy: 84.07142639160156%\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iteration: 5500  Loss: 0.7409000992774963  Accuracy: 84.32142639160156%\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iteration: 6000  Loss: 0.8616995215415955  Accuracy: 84.63095092773438%\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iteration: 6500  Loss: 0.6559227705001831  Accuracy: 84.89286041259766%\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iteration: 7000  Loss: 0.7093676924705505  Accuracy: 85.10713958740234%\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iteration: 7500  Loss: 0.6372642517089844  Accuracy: 85.32142639160156%\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iteration: 8000  Loss: 0.7372314929962158  Accuracy: 85.48809814453125%\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iteration: 8500  Loss: 0.542898952960968  Accuracy: 85.64286041259766%\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iteration: 9000  Loss: 0.6680330038070679  Accuracy: 85.75%\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iteration: 9500  Loss: 0.5265533924102783  Accuracy: 85.91666412353516%\n"
+     ]
+    }
+   ],
+   "source": [
+    "# 모델 학습\n",
+    "count = 0\n",
+    "loss_list = []\n",
+    "iteration_list = []\n",
+    "for epoch in range(num_epochs):\n",
+    "    for i, (images, labels) in enumerate(train_loader):\n",
+    "\n",
+    "        # 변수 정의\n",
+    "        train = Variable(images.view(-1, 28 * 28))\n",
+    "        labels = Variable(labels)\n",
+    "\n",
+    "        # 경사 초기화\n",
+    "        optimizer.zero_grad()\n",
+    "\n",
+    "        # 순전파\n",
+    "        outputs = model(train)\n",
+    "\n",
+    "        # 소프트맥스 및 크로스 엔트로피 손실 계산\n",
+    "        loss = error(outputs, labels)\n",
+    "\n",
+    "        # 역전파를 통한 경사 계산\n",
+    "        loss.backward()\n",
+    "\n",
+    "        # 가중치 업데이트\n",
+    "        optimizer.step()\n",
+    "\n",
+    "        count += 1\n",
+    "\n",
+    "        # 정확도 측정\n",
+    "        if count % 50 == 0:\n",
+    "            correct = 0\n",
+    "            total = 0\n",
+    "            # 테스트 데이터셋 예측 수행\n",
+    "            for images, labels in test_loader:\n",
+    "                test = Variable(images.view(-1, 28 * 28))\n",
+    "\n",
+    "                # 순전파\n",
+    "                outputs = model(test)\n",
+    "\n",
+    "                # 최댓값을 기준으로 예측값 결정\n",
+    "                predicted = torch.max(outputs.data, 1)[1]\n",
+    "\n",
+    "                # 전체 라벨 개수\n",
+    "                total += len(labels)\n",
+    "\n",
+    "                # 맞춘 개수 계산\n",
+    "                correct += (predicted == labels).sum()\n",
+    "\n",
+    "            accuracy = 100 * correct / float(total)\n",
+    "\n",
+    "            # 손실 및 반복 횟수 저장\n",
+    "            loss_list.append(loss.data)\n",
+    "            iteration_list.append(count)\n",
+    "\n",
+    "        # 500번마다 손실 출력\n",
+    "        if count % 500 == 0:\n",
+    "            print('Iteration: {}  Loss: {}  Accuracy: {}%'.format(count, loss.data, accuracy))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 472
+    },
+    "execution": {
+     "iopub.execute_input": "2026-09-14T14:41:42.385912Z",
+     "iopub.status.busy": "2026-09-14T14:41:42.385265Z",
+     "iopub.status.idle": "2026-09-14T14:41:42.473995Z",
+     "shell.execute_reply": "2026-09-14T14:41:42.473118Z"
+    },
+    "id": "FctKP-1E8CVh",
+    "outputId": "33b41bbb-5688-4457-a44e-b4f83053881b"
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# 시각화\n",
+    "plt.plot(iteration_list,loss_list)\n",
+    "plt.xlabel(\"Number of iteration\")\n",
+    "plt.ylabel(\"Loss\")\n",
+    "plt.title(\"Logistic Regression: Loss vs Number of iteration\")\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "colab": {
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "Python 3",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
diff --git "a/Week1\341\204\213\341\205\250\341\204\211\341\205\263\341\206\270\341\204\200\341\205\252\341\204\214\341\205\246_\341\204\222\341\205\241\341\206\253\341\204\211\341\205\256\341\204\213\341\205\247\341\206\253.ipynb" "b/Week1\341\204\213\341\205\250\341\204\211\341\205\263\341\206\270\341\204\200\341\205\252\341\204\214\341\205\246_\341\204\222\341\205\241\341\206\253\341\204\211\341\205\256\341\204\213\341\205\247\341\206\253.ipynb"
new file mode 100644
index 0000000..5b63c40
--- /dev/null
+++ "b/Week1\341\204\213\341\205\250\341\204\211\341\205\263\341\206\270\341\204\200\341\205\252\341\204\214\341\205\246_\341\204\222\341\205\241\341\206\253\341\204\211\341\205\256\341\204\213\341\205\247\341\206\253.ipynb"
@@ -0,0 +1,451 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "c5827ecd",
+   "metadata": {},
+   "source": [
+    "# 2장 코드 필사"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "376faae1",
+   "metadata": {},
+   "source": [
+    "### 코드 2-1 필요한 라이브러리 호출"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "02c0f0b6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "import numpy as np    # 벡터 및 행렬 연산에서 매우 편리한 기능을 제공하는 파이썬 라이브러리 패키지\n",
+    "import pandas as pd   # 데이터 처리를 위해 널리 사용되는 파이썬 라이브러리 패키지\n",
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns\n",
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a2e831e0",
+   "metadata": {},
+   "source": [
+    "### 코드 2-2 데이터 호출"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fed5dc3d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dataset = pd.read_csv('../chap02/data/car_evaluation.csv')   # ①\n",
+    "dataset.head()   # ②"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9921d66a",
+   "metadata": {},
+   "source": [
+    "### 코드 2-3 예제 데이터셋 분포"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "45f7008b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fig_size = plt.rcParams[\"figure.figsize\"]\n",
+    "fig_size[0] = 8\n",
+    "fig_size[1] = 6\n",
+    "plt.rcParams[\"figure.figsize\"] = fig_size\n",
+    "dataset.output.value_counts().plot(kind='pie', autopct='%0.05f%%',\n",
+    "colors=['lightblue', 'lightgreen', 'orange', 'pink'], explode=(0.05, 0.05, 0.05, 0.05))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e66f32a1",
+   "metadata": {},
+   "source": [
+    "### 코드 2-4 데이터를 범주형 타입으로 변환"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6b55ac55",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "categorical_columns = ['price', 'maint', 'doors', 'persons', 'lug_capacity', 'safety']   # 예제 데이터셋 칼럼들의 목록\n",
+    "\n",
+    "for category in categorical_columns:\n",
+    "    dataset[category] = dataset[category].astype('category')   # astype() 메서드를 이용하여 데이터를 범주형으로 변환\n",
+    "\n",
+    "price = dataset['price'].cat.codes.values   # ①\n",
+    "maint = dataset['maint'].cat.codes.values\n",
+    "doors = dataset['doors'].cat.codes.values\n",
+    "persons = dataset['persons'].cat.codes.values\n",
+    "lug_capacity = dataset['lug_capacity'].cat.codes.values\n",
+    "safety = dataset['safety'].cat.codes.values\n",
+    "\n",
+    "categorical_data = np.stack([price, maint, doors, persons, lug_capacity, safety], 1)   # ②\n",
+    "categorical_data[:10]   # 합친 넘파이 배열 중 열 개의 행을 출력하여 보여 줍니다."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "31faec91",
+   "metadata": {},
+   "source": [
+    "### 코드 2-5 배열을 텐서로 변환"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f4796ed7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "categorical_data = torch.tensor(categorical_data, dtype=torch.int64)\n",
+    "categorical_data[:10]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "56585313",
+   "metadata": {},
+   "source": [
+    "### 코드 2-6 레이블로 사용할 칼럼을 텐서로 변환"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b6faca86",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "outputs = pd.get_dummies(dataset.output)   # ①\n",
+    "outputs = outputs.values\n",
+    "outputs = torch.tensor(outputs).flatten()   # 1차원 텐서로 변환\n",
+    "\n",
+    "print(categorical_data.shape)\n",
+    "print(outputs.shape)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "21b4b345",
+   "metadata": {},
+   "source": [
+    "### 코드 2-7 범주형 칼럼을 N차원으로 변환"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "26dd8182",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "categorical_column_sizes = [len(dataset[column].cat.categories) for column in\n",
+    "                            categorical_columns]\n",
+    "categorical_embedding_sizes = [(col_size, min(50, (col_size+1)//2)) for col_size in\n",
+    "                               categorical_column_sizes]\n",
+    "print(categorical_embedding_sizes)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ee2ef75c",
+   "metadata": {},
+   "source": [
+    "### 코드 2-8 데이터셋 분리"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "78d94e01",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "total_records = 1728\n",
+    "test_records = int(total_records * .2)   # 전체 데이터 중 20%를 테스트 용도로 사용\n",
+    "\n",
+    "categorical_train_data = categorical_data[:total_records - test_records]\n",
+    "categorical_test_data = categorical_data[total_records - test_records:total_records]\n",
+    "train_outputs = outputs[:total_records - test_records]\n",
+    "test_outputs = outputs[total_records - test_records:total_records]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "20f7bc76",
+   "metadata": {},
+   "source": [
+    "### 코드 2-9 데이터셋 분리 확인"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1db2019f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(len(categorical_train_data))\n",
+    "print(len(train_outputs))\n",
+    "print(len(categorical_test_data))\n",
+    "print(len(test_outputs))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "81a5d0cf",
+   "metadata": {},
+   "source": [
+    "### 코드 2-10 모델의 네트워크 생성"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "35111ea3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class Model(nn.Module):   # ①\n",
+    "    def __init__(self, embedding_size, output_size, layers, p=0.4):   # ②\n",
+    "        super().__init__()   # ③\n",
+    "        self.all_embeddings = nn.ModuleList([nn.Embedding(ni, nf) for ni,\n",
+    "                                             nf in embedding_size])\n",
+    "        self.embedding_dropout = nn.Dropout(p)\n",
+    "\n",
+    "        all_layers = []\n",
+    "        num_categorical_cols = sum((nf for ni, nf in embedding_size))\n",
+    "        input_size = num_categorical_cols   # 입력층의 크기를 찾기 위해 범주형 칼럼 개수를 input_size 변수에 저장\n",
+    "\n",
+    "        for i in layers:   # ④\n",
+    "            all_layers.append(nn.Linear(input_size, i))\n",
+    "            all_layers.append(nn.ReLU(inplace=True))\n",
+    "            all_layers.append(nn.BatchNorm1d(i))\n",
+    "            all_layers.append(nn.Dropout(p))\n",
+    "            input_size = i\n",
+    "\n",
+    "        all_layers.append(nn.Linear(layers[-1], output_size))\n",
+    "        self.layers = nn.Sequential(*all_layers)   # 신경망의 모든 계층이 순차적으로 실행되도록 모든 계층에 대한 목록(all_layers)을 nn.Sequential 클래스로 전달\n",
+    "\n",
+    "    def forward(self, x_categorical):   # ⑤\n",
+    "        embeddings = []\n",
+    "        for i,e in enumerate(self.all_embeddings):\n",
+    "            embeddings.append(e(x_categorical[:,i]))\n",
+    "        x = torch.cat(embeddings, 1)   # 넘파이의 concatenate와 같지만 대상이 텐서가 됩니다.\n",
+    "        x = self.embedding_dropout(x)\n",
+    "        x = self.layers(x)\n",
+    "        return x"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "65c169c8",
+   "metadata": {},
+   "source": [
+    "### 코드 2-11 Model 클래스의 객체 생성"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ccba3dc7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model = Model(categorical_embedding_sizes, 4, [200,100,50], p=0.4)\n",
+    "print(model)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "afd43c97",
+   "metadata": {},
+   "source": [
+    "### 코드 2-12 모델의 파라미터 정의"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "46e0987a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "loss_function = nn.CrossEntropyLoss()\n",
+    "optimizer = torch.optim.Adam(model.parameters(), lr=0.001)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d6ae2f86",
+   "metadata": {},
+   "source": [
+    "### 코드 2-13 CPU/GPU 사용 지정"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b742add4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if torch.cuda.is_available():\n",
+    "    device = torch.device('cuda')   # GPU가 있다면 GPU를 사용\n",
+    "else:\n",
+    "    device = torch.device('cpu')   # GPU가 없다면 CPU를 사용"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "274b1d2f",
+   "metadata": {},
+   "source": [
+    "### 코드 2-14 모델 학습"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "39228dca",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "epochs = 500\n",
+    "aggregated_losses = []\n",
+    "train_outputs = train_outputs.to(device=device, dtype=torch.int64)\n",
+    "\n",
+    "for i in range(epochs):   # for 문은 500회 반복되며, 각 반복마다 손실 함수가 오차를 계산\n",
+    "    i += 1\n",
+    "    y_pred = model(categorical_train_data).to(device)\n",
+    "    single_loss = loss_function(y_pred, train_outputs)\n",
+    "    aggregated_losses.append(single_loss)   # 반복할 때마다 오차를 aggregated_losses에 추가\n",
+    "\n",
+    "    if i%25 == 1:\n",
+    "        print(f'epoch: {i:3} loss: {single_loss.item():10.8f}')\n",
+    "\n",
+    "    optimizer.zero_grad()\n",
+    "    single_loss.backward()   # 가중치를 업데이트하기 위해 손실 함수의 backward() 메서드 호출\n",
+    "    optimizer.step()   # 옵티마이저 함수의 step() 메서드를 이용하여 기울기 업데이트\n",
+    "\n",
+    "print(f'epoch: {i:3} loss: {single_loss.item():10.10f}')   # 오차가 25 에포크마다 출력"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c3883ed9",
+   "metadata": {},
+   "source": [
+    "### 코드 2-15 테스트 데이터셋으로 모델 예측"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "74353de4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "test_outputs = test_outputs.to(device=device, dtype=torch.int64)\n",
+    "with torch.no_grad():\n",
+    "    y_val = model(categorical_test_data)\n",
+    "    loss = loss_function(y_val, test_outputs)\n",
+    "print(f'Loss: {loss:.8f}')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3b9f9f03",
+   "metadata": {},
+   "source": [
+    "### 코드 2-16 모델의 예측 확인"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "291d4d86",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(y_val[:5])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a4694bb6",
+   "metadata": {},
+   "source": [
+    "### 코드 2-17 가장 큰 값을 갖는 인덱스 확인"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8f69e59d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "y_val = np.argmax(y_val, axis=1)\n",
+    "print(y_val[:5])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "03cf52a7",
+   "metadata": {},
+   "source": [
+    "### 코드 2-18 테스트 데이터셋을 이용한 정확도 확인"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "830f02bd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sklearn.metrics import classification_report, confusion_matrix, accuracy_score\n",
+    "print(confusion_matrix(test_outputs,y_val))\n",
+    "print(classification_report(test_outputs,y_val))\n",
+    "print(accuracy_score(test_outputs, y_val))"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python",
+   "version": "3.x"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git "a/Week1\341\204\213\341\205\250\341\204\211\341\205\263\341\206\270\341\204\200\341\205\252\341\204\214\341\205\246_\341\204\222\341\205\241\341\206\253\341\204\211\341\205\256\341\204\213\341\205\247\341\206\253.pdf" "b/Week1\341\204\213\341\205\250\341\204\211\341\205\263\341\206\270\341\204\200\341\205\252\341\204\214\341\205\246_\341\204\222\341\205\241\341\206\253\341\204\211\341\205\256\341\204\213\341\205\247\341\206\253.pdf"
new file mode 100644
index 0000000..b4ab420
Binary files /dev/null and "b/Week1\341\204\213\341\205\250\341\204\211\341\205\263\341\206\270\341\204\200\341\205\252\341\204\214\341\205\246_\341\204\222\341\205\241\341\206\253\341\204\211\341\205\256\341\204\213\341\205\247\341\206\253.pdf" differ