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\200\341\205\265\341\206\267\341\204\200\341\205\265\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\200\341\205\265\341\206\267\341\204\200\341\205\265\341\204\213\341\205\247\341\206\253.ipynb"
new file mode 100644
index 0000000..dc49664
--- /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\200\341\205\265\341\206\267\341\204\200\341\205\265\341\204\213\341\205\247\341\206\253.ipynb"
@@ -0,0 +1,990 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# **Week1 복습과제**\n",
+        "\n",
+        "1. [Pytorch 기본]\n",
+        "1. [Linear Regression]\n",
+        "1. [Logistic Regression]"
+      ],
+      "metadata": {
+        "id": "9mabISNcCPiV"
+      }
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 3,
+      "metadata": {
+        "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",
+      "source": [
+        "<a id=\"1\"></a> <br>\n",
+        "## 1. Pytorch 기본"
+      ],
+      "metadata": {
+        "id": "0qcO6qTxCUTU"
+      }
+    },
+    {
+      "cell_type": "code",
+      "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)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "_KdP4S5g7udz",
+        "outputId": "748c8f9a-92a4-4a04-aa2f-31a3d6257d33"
+      },
+      "execution_count": 4,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Array Type: <class 'numpy.ndarray'>\n",
+            "Array Shape: (2, 3)\n",
+            "[[1 2 3]\n",
+            " [4 5 6]]\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "- 우리는 NumPy 배열을 살펴보았습니다.\n",
+        "- 이제 텐서(PyTorch 배열)를 구현하는 방법을 살펴보겠습니다.\n",
+        "- import torch를 사용하여 PyTorch 라이브러리를 가져옵니다.\n",
+        "- torch.Tensor() 메서드를 사용하여 텐서를 생성합니다.\n",
+        "- type: 배열의 타입을 나타냅니다. 이 예제에서는 텐서입니다.\n",
+        "- shape: 배열의 형태를 나타냅니다. (행 × 열)"
+      ],
+      "metadata": {
+        "id": "HfLiM-u1Cj5l"
+      }
+    },
+    {
+      "cell_type": "code",
+      "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)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "d-uAA50o7ua4",
+        "outputId": "b0e639b9-f95f-4275-dcce-18cb5c2ec557"
+      },
+      "execution_count": 5,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Array Type: <class 'torch.Tensor'>\n",
+            "Array Shape: torch.Size([2, 3])\n",
+            "tensor([[1., 2., 3.],\n",
+            "        [4., 5., 6.]])\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "- 할당(Allocation)은 코딩에서 가장 많이 사용되는 기법 중 하나입니다.\n",
+        "- 따라서 PyTorch를 사용하여 이를 구현하는 방법을 배워봅시다.\n",
+        "- 학습을 위해 NumPy와 Tensor를 비교해 봅시다.\n",
+        "  - np.ones() = torch.ones()\n",
+        "  - np.random.rand() = torch.rand()"
+      ],
+      "metadata": {
+        "id": "pEvocwKPC6J1"
+      }
+    },
+    {
+      "cell_type": "code",
+      "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"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "QlHQXzBR7uYo",
+        "outputId": "e6ab71af-7d3b-45e4-d2f3-fad043576bcb"
+      },
+      "execution_count": 6,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Numpy [[1. 1. 1.]\n",
+            " [1. 1. 1.]]\n",
+            "\n",
+            "tensor([[1., 1., 1.],\n",
+            "        [1., 1., 1.]])\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "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"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "xEV88BpO7uWc",
+        "outputId": "1a38895e-f854-49fc-87cf-08951a8605ed"
+      },
+      "execution_count": 7,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Numpy [[0.29250733 0.26986328 0.57111316]\n",
+            " [0.79297649 0.66416663 0.49793699]]\n",
+            "\n",
+            "tensor([[0.8991, 0.0210, 0.3326],\n",
+            "        [0.5247, 0.7755, 0.5756]])\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "- 텐서와 NumPy 배열 간의 변환을 살펴봅시다.\n",
+        "  - torch.from_numpy(): NumPy → Tensor\n",
+        "  - .numpy(): Tensor → NumPy"
+      ],
+      "metadata": {
+        "id": "2TAOGUteDLOv"
+      }
+    },
+    {
+      "cell_type": "code",
+      "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))"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "yWShZwKC7uUM",
+        "outputId": "d0b2fcae-222d-45f3-e4e1-abcf1babd132"
+      },
+      "execution_count": 8,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "<class 'numpy.ndarray'> [[0.07129916 0.34166541]\n",
+            " [0.46849638 0.59131477]]\n",
+            "\n",
+            "tensor([[0.0713, 0.3417],\n",
+            "        [0.4685, 0.5913]], dtype=torch.float64)\n",
+            "\n",
+            "<class 'numpy.ndarray'> [[0.07129916 0.34166541]\n",
+            " [0.46849638 0.59131477]]\n",
+            "\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "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"
+      ],
+      "metadata": {
+        "id": "bsJkMU_lDZgy"
+      }
+    },
+    {
+      "cell_type": "code",
+      "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()))"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "V6iLiAPS7uQs",
+        "outputId": "f43b5723-d22f-43d2-94bc-98ca67a7eb80"
+      },
+      "execution_count": 9,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "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"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "### Variables  \n",
+        "- 변수는 그래디언트(Gradients)를 누적합니다.\n",
+        "- 우리는 PyTorch를 신경망에 사용할 것입니다. 신경망에서는 역전파(Backpropagation) 과정에서 그래디언트를 계산하게 됩니다. 따라서 그래디언트를 다룰 필요가 있습니다.\n",
+        "- 변수(Variable)와 텐서(Tensor)의 차이점은 변수가 그래디언트를 누적한다는 것입니다.  \n",
+        "- 변수를 사용하여 수학 연산을 수행할 수도 있습니다.  \n",
+        "- 역전파를 수행하려면 변수가 필요합니다."
+      ],
+      "metadata": {
+        "id": "HxVIlKSQEIXx"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from torch.autograd import Variable\n",
+        "\n",
+        "# variable 정의\n",
+        "var = Variable(torch.ones(3), requires_grad = True)"
+      ],
+      "metadata": {
+        "id": "UfpDKji97uOv"
+      },
+      "execution_count": 10,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "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)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "t4p2w1z_7uMv",
+        "outputId": "9c4ca8fa-dd12-453d-86b6-9ae8ac39b37f"
+      },
+      "execution_count": 11,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            " y =   tensor([ 4., 16.], grad_fn=<PowBackward0>)\n",
+            " o =   tensor(10., grad_fn=<MulBackward0>)\n",
+            "gradients:  tensor([2., 4.])\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "<a id=\"2\"></a> <br>\n",
+        "## 2. 선형 회귀\n",
+        "\n",
+        "- y = Ax + B\n",
+        "    - A = 기울기\n",
+        "    - B = 절편 (y축과 교차하는 점)\n",
+        "\n",
+        "- 자동차 가격이 낮으면 더 많이 팔리고, 자동차 가격이 높으면 덜 팔린다는 사실을 우리는 알고 있으며, 이에 대한 데이터셋을 가지고 있습니다.\n",
+        "\n",
+        "- 목표는 자동차 가격이 100일 때 팔린 자동차의 수를 예측하는 것입니다."
+      ],
+      "metadata": {
+        "id": "Jq1tID2f9DOP"
+      }
+    },
+    {
+      "cell_type": "code",
+      "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()"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 472
+        },
+        "id": "5r4kXCwf7uKP",
+        "outputId": "22a1a3db-924d-4415-cd6d-b81ae30e47b9"
+      },
+      "execution_count": 12,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "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)"
+      ],
+      "metadata": {
+        "id": "MOlzmdG89JCT"
+      }
+    },
+    {
+      "cell_type": "code",
+      "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_dim,output_dim) # 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()"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 824
+        },
+        "id": "6MvDUc9b7uHf",
+        "outputId": "0c8fdcd5-b32c-412a-9a06-8f659966f533"
+      },
+      "execution_count": 13,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "epoch 0, loss 55.854759216308594\n",
+            "epoch 50, loss 5.435788631439209\n",
+            "epoch 100, loss 3.673189640045166\n",
+            "epoch 150, loss 2.482128143310547\n",
+            "epoch 200, loss 1.6772778034210205\n",
+            "epoch 250, loss 1.1334071159362793\n",
+            "epoch 300, loss 0.7658900022506714\n",
+            "epoch 350, loss 0.5175440907478333\n",
+            "epoch 400, loss 0.34972625970840454\n",
+            "epoch 450, loss 0.23632462322711945\n",
+            "epoch 500, loss 0.15969453752040863\n",
+            "epoch 550, loss 0.10791231691837311\n",
+            "epoch 600, loss 0.07292093336582184\n",
+            "epoch 650, loss 0.049275148659944534\n",
+            "epoch 700, loss 0.03329743817448616\n",
+            "epoch 750, loss 0.0225005391985178\n",
+            "epoch 800, loss 0.015204519033432007\n",
+            "epoch 850, loss 0.010274389758706093\n",
+            "epoch 900, loss 0.006942908279597759\n",
+            "epoch 950, loss 0.004691654350608587\n",
+            "epoch 1000, loss 0.003170259762555361\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "- 반복 횟수는 1000입니다.\n",
+        "- 손실 값은 거의 0에 가까우며, 이는 그래프나 1000번째 epoch에서의 손실 값에서 확인할 수 있습니다.\n",
+        "- 이제 우리는 훈련된 모델을 가지고 있습니다.\n",
+        "- 훈련된 모델을 사용할 때, 자동차 가격을 예측해 봅시다."
+      ],
+      "metadata": {
+        "id": "9odY_Wb59N8H"
+      }
+    },
+    {
+      "cell_type": "code",
+      "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.Tensor([[10]]))).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()"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 472
+        },
+        "id": "FtsHa2uk7uDy",
+        "outputId": "b7abab91-743f-4a3a-890b-346be975dfca"
+      },
+      "execution_count": 18,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "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%까지 증가하며 모델이 훈련되고 있음을 확인할 수 있습니다."
+      ],
+      "metadata": {
+        "id": "7uXrwVTU9VFH"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import torch\n",
+        "import torch.nn as nn\n",
+        "from torch.autograd import Variable\n",
+        "from torch.utils.data import DataLoader\n",
+        "import pandas as pd\n",
+        "from sklearn.model_selection import train_test_split"
+      ],
+      "metadata": {
+        "id": "FvnI_38-8CfS"
+      },
+      "execution_count": 19,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "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)\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 = torch.utils.data.TensorDataset(featuresTrain, targetsTrain)\n",
+        "test = torch.utils.data.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()"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 428
+        },
+        "id": "cPmM5DM48Cb6",
+        "outputId": "d6a42926-093a-4c00-f97c-f56e5bab7f41"
+      },
+      "execution_count": 27,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from google.colab import drive\n",
+        "drive.mount('/content/drive')"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "xbEmp_siLfPU",
+        "outputId": "81e7367a-0eb8-425d-c46e-bea01490b826"
+      },
+      "execution_count": 28,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Mounted at /content/drive\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "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를 사용합니다"
+      ],
+      "metadata": {
+        "id": "S73aSJuz8CZq"
+      },
+      "execution_count": 31,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "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))"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "Oc4X8eZt8CXq",
+        "outputId": "21476936-6fc7-4f69-d9cd-9c9209ea23c8"
+      },
+      "execution_count": 32,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Iteration: 500  Loss: 1.8338176012039185  Accuracy: 66.05952453613281%\n",
+            "Iteration: 1000  Loss: 1.6047519445419312  Accuracy: 74.48809814453125%\n",
+            "Iteration: 1500  Loss: 1.3232487440109253  Accuracy: 77.9047622680664%\n",
+            "Iteration: 2000  Loss: 1.2046371698379517  Accuracy: 79.67857360839844%\n",
+            "Iteration: 2500  Loss: 1.050527572631836  Accuracy: 80.79762268066406%\n",
+            "Iteration: 3000  Loss: 0.9377113580703735  Accuracy: 81.61904907226562%\n",
+            "Iteration: 3500  Loss: 0.907156765460968  Accuracy: 82.21428680419922%\n",
+            "Iteration: 4000  Loss: 0.7552305459976196  Accuracy: 82.73809814453125%\n",
+            "Iteration: 4500  Loss: 0.9776384830474854  Accuracy: 83.17857360839844%\n",
+            "Iteration: 5000  Loss: 0.8130481243133545  Accuracy: 83.61904907226562%\n",
+            "Iteration: 5500  Loss: 0.7536363005638123  Accuracy: 83.96428680419922%\n",
+            "Iteration: 6000  Loss: 0.870861291885376  Accuracy: 84.35713958740234%\n",
+            "Iteration: 6500  Loss: 0.6571878790855408  Accuracy: 84.6547622680664%\n",
+            "Iteration: 7000  Loss: 0.7159831523895264  Accuracy: 84.86904907226562%\n",
+            "Iteration: 7500  Loss: 0.6358954906463623  Accuracy: 85.13095092773438%\n",
+            "Iteration: 8000  Loss: 0.7491896748542786  Accuracy: 85.22618865966797%\n",
+            "Iteration: 8500  Loss: 0.5461571216583252  Accuracy: 85.42857360839844%\n",
+            "Iteration: 9000  Loss: 0.6598911881446838  Accuracy: 85.5%\n",
+            "Iteration: 9500  Loss: 0.5324509143829346  Accuracy: 85.53571319580078%\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "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": {
+          "base_uri": "https://localhost:8080/",
+          "height": 472
+        },
+        "id": "FctKP-1E8CVh",
+        "outputId": "a73761a4-16e8-40dd-d988-b1c1f178c942"
+      },
+      "execution_count": 33,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    }
+  ]
+}
\ No newline at end of file
diff --git "a/Week2_\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\200\341\205\265\341\206\267\341\204\200\341\205\265\341\204\213\341\205\247\341\206\253.pdf" "b/Week2_\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\200\341\205\265\341\206\267\341\204\200\341\205\265\341\204\213\341\205\247\341\206\253.pdf"
new file mode 100644
index 0000000..005eb68
Binary files /dev/null and "b/Week2_\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\200\341\205\265\341\206\267\341\204\200\341\205\265\341\204\213\341\205\247\341\206\253.pdf" differ
diff --git "a/Week2_\341\204\221\341\205\265\341\206\257\341\204\211\341\205\241_\341\204\200\341\205\265\341\206\267\341\204\200\341\205\265\341\204\213\341\205\247\341\206\253.ipynb" "b/Week2_\341\204\221\341\205\265\341\206\257\341\204\211\341\205\241_\341\204\200\341\205\265\341\206\267\341\204\200\341\205\265\341\204\213\341\205\247\341\206\253.ipynb"
new file mode 100644
index 0000000..6f9b5b6
--- /dev/null
+++ "b/Week2_\341\204\221\341\205\265\341\206\257\341\204\211\341\205\241_\341\204\200\341\205\265\341\206\267\341\204\200\341\205\265\341\204\213\341\205\247\341\206\253.ipynb"
@@ -0,0 +1,124 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "bPdqS-lO01rt"
+      },
+      "outputs": [],
+      "source": [
+        "class Net(torch.nn.Module):\n",
+        "  def __init__(self, n_feature, n_hidden, n_output):\n",
+        "    super(Net, selt).__init__()\n",
+        "    self.hidden = torch.nn.Linear(n_feature, n_hidden)\n",
+        "    self.relu = torch.nn.ReLu(inplace=True)\n",
+        "    self.out = torch.nn.Linear(n_hidden, n_output)\n",
+        "    self.softmax = torch.nn.Softmax(dim=n_output)\n",
+        "  def forward(self, x):\n",
+        "    x = self.hidden(x)\n",
+        "    x = self.relu(x)\n",
+        "    x = self.out(x)\n",
+        "    x = self.softmax(x)\n",
+        "    return x"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import torch\n",
+        "\n",
+        "loss_fn = torch.nn.MSELoss(reduction='sum')\n",
+        "y_pred = model(x)\n",
+        "loss = loss_fn(y_pred, y)"
+      ],
+      "metadata": {
+        "id": "eXv-itln2cE5"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "loss = nn.CrossEntropyLoss()\n",
+        "input = torch.randn(5,6,requires_grad=True)\n",
+        "target = torch.empty(3, dtype=torch.long).random_(5)\n",
+        "output = loss(input, target)\n",
+        "output.backward()"
+      ],
+      "metadata": {
+        "id": "YLyT_-7J2q8B"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "class DropoutModel(torch.nn.Module):\n",
+        "  def __init__(self):\n",
+        "    super(DropoutModel, self).__init__()\n",
+        "    self.layer1 = torch.nn.Linear(784, 1200)\n",
+        "    self.dropout1 = torch.nn.Dropout(0.5)\n",
+        "    self.layer2 = torch.nn.Linear(1200, 1200)\n",
+        "    self.dropout2 = torch.nn.Dropout(0.5)\n",
+        "    self.layer3 = torch.nn.Linear(1200, 10)\n",
+        "\n",
+        "  def forward(self, x):\n",
+        "    x = F.relu(self.layer1(x))\n",
+        "    x = self.dropout1(x)\n",
+        "    x = F.relu(self.layer2(x))\n",
+        "    x = self.dropout2(x)\n",
+        "    return self.layer3(x)\n"
+      ],
+      "metadata": {
+        "id": "G-FC_0Nr27Ju"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "class CustomDataset(Dataset):\n",
+        "  def __init__(self):\n",
+        "    self.x_data = [[1,2,3],[4,5,6],[7,8,9]]\n",
+        "    self.y_data = [[12],[18],[11]]\n",
+        "    def __len__(self):\n",
+        "      return len(self.x_data)\n",
+        "    def __getitem__(self, idx):\n",
+        "      x = torch.FloatTensor(self.x_data[idx])\n",
+        "      y = torch.FloatTensor(self.y_data[idx])\n",
+        "      return x,y\n",
+        "\n",
+        "dataset = CustomDataset()\n",
+        "dataloader = DataLoader(\n",
+        "    dataset,\n",
+        "    batch_size=2,\n",
+        "    shuffle=True\n",
+        ")\n",
+        "\n"
+      ],
+      "metadata": {
+        "id": "BHvPnz-Z3rJ4"
+      },
+      "execution_count": null,
+      "outputs": []
+    }
+  ]
+}
\ No newline at end of file