L04_1_Linear_Regression_Practice.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "#  텐서 Tensor 만들기"
      ],
      "metadata": {
        "id": "6ayxpkPRh2yx"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "O62-G1OUMFgy",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "20e5bc44-62d3-4df5-8d10-97563a6ca956"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "x = tensor([[1, 2, 3],\n",
            "        [4, 5, 6],\n",
            "        [7, 8, 9]])\n",
            "y = tensor([[1., 2., 3.],\n",
            "        [4., 5., 6.],\n",
            "        [7., 8., 9.]])\n",
            "torch.LongTensor\n",
            "torch.Size([3, 3])\n",
            "torch.Size([3, 3])\n",
            "2\n",
            "2\n",
            "2\n"
          ]
        }
      ],
      "source": [
        "import torch\n",
        "\n",
        "# tensor 만들어 보기\n",
        "x = torch.tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]])\n",
        "y = torch.tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=torch.float)\n",
        "print(\"x =\", x)\n",
        "print(\"y =\", y)\n",
        "\n",
        "print(x.type()) #float 이 출력됨\n",
        "\n",
        "# tensor 의 모양 알아보기. 몇 행 몇 열\n",
        "print(x.shape) #size 보다 shape을 많이쓴다. 둘 다 동일\n",
        "print(x.size())\n",
        "\n",
        "# rank 알아보기 (차원)\n",
        "print(len(x.shape))\n",
        "# 아래 둘은 같음\n",
        "print(x.ndimension())\n",
        "print(x.ndim) # 많이 씀"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 텐서 모양 바꾸기"
      ],
      "metadata": {
        "id": "j9_cxWZBjZ9h"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# 텐서 모양 바꾸기\n",
        "# - unsqueeze(x, i): tensor x에 i 번째 차원 추가, 차원을 늘림\n",
        "\n",
        "# 같은 값을 가지지만 모양이 다른 애를 만들때 사용\n",
        "\n",
        "x0 = torch.unsqueeze(x, 0) # 0번째에 차원 추가\n",
        "x1 = torch.unsqueeze(x, 1) # 1번째에 차원 추가\n",
        "x2 = torch.unsqueeze(x, 2) # 2번째에 차원 추가\n",
        "\n",
        "print(x0)\n",
        "print(x0.shape)\n",
        "print(x1)\n",
        "print(x1.shape)\n",
        "print(x2)\n",
        "print(x2.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KVDPUCwaiC3f",
        "outputId": "414afdca-4020-45cd-9a3b-67e41a032faa"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([[[1, 2, 3],\n",
            "         [4, 5, 6],\n",
            "         [7, 8, 9]]])\n",
            "torch.Size([1, 3, 3])\n",
            "tensor([[[1, 2, 3]],\n",
            "\n",
            "        [[4, 5, 6]],\n",
            "\n",
            "        [[7, 8, 9]]])\n",
            "torch.Size([3, 1, 3])\n",
            "tensor([[[1],\n",
            "         [2],\n",
            "         [3]],\n",
            "\n",
            "        [[4],\n",
            "         [5],\n",
            "         [6]],\n",
            "\n",
            "        [[7],\n",
            "         [8],\n",
            "         [9]]])\n",
            "torch.Size([3, 3, 1])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 텐서 모양 바꾸기\n",
        "# - squeeze(x): 텐서 x에서 크기가 1인 차원 제거\n",
        " \n",
        "print(x0)\n",
        "print(x0.shape)\n",
        "\n",
        "x00 = torch.squeeze(x0) # 1이 포함된 차원 제거\n",
        "print(x00)\n",
        "print(x00.shape)\n",
        "\n",
        "x02 = torch.unsqueeze(x0, 2)\n",
        "print(x02)\n",
        "print(x02.shape)\n",
        "\n",
        "x01 = torch.squeeze(x02) # 1이 포함된 차원 모두 제거\n",
        "print(x01)\n",
        "print(x01.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fGirf-FMi7ag",
        "outputId": "a04bb448-1e81-461c-85ec-e1a3a1f5a4dc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([[[1, 2, 3],\n",
            "         [4, 5, 6],\n",
            "         [7, 8, 9]]])\n",
            "torch.Size([1, 3, 3])\n",
            "tensor([[1, 2, 3],\n",
            "        [4, 5, 6],\n",
            "        [7, 8, 9]])\n",
            "torch.Size([3, 3])\n",
            "tensor([[[[1, 2, 3]],\n",
            "\n",
            "         [[4, 5, 6]],\n",
            "\n",
            "         [[7, 8, 9]]]])\n",
            "torch.Size([1, 3, 1, 3])\n",
            "tensor([[1, 2, 3],\n",
            "        [4, 5, 6],\n",
            "        [7, 8, 9]])\n",
            "torch.Size([3, 3])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 유연하게 모양을 바꿈 \n",
        "# - x.view([shape]): x를 [shape]의 모양으로 변환\n",
        "\n",
        "print(x)\n",
        "\n",
        "xView9 = x.view(9) # view()안의 값은 사이즈를 잘 보고 (알맞게) 넣어야함\n",
        "\n",
        "print(xView9)\n",
        "print(xView9.shape)\n",
        "\n",
        "# 몇 개인지는 모르겠지만 한 줄로 쭉 보여주고 싶다 -> -1 사용 (데이터의 모양을 정확히 알지 못할때)\n",
        "xV = x.view(-1)\n",
        "print(xV)\n",
        "\n",
        "# 마지막꺼는 알아서 채워줬으면 좋겠다 하면 마지막에 -1\n",
        "xV2 = x.view(1, 3, -1) #-1을 두 군데에 쓸 수는 없음\n",
        "print(xV2)\n",
        "\n",
        "# 기존 x 와 동일\n",
        "xV3 = x.view(3, 3 )\n",
        "print(xV3)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pDTtdQLwjoBd",
        "outputId": "80fbf332-3de2-4bb8-d630-0811af8acd27"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([[1, 2, 3],\n",
            "        [4, 5, 6],\n",
            "        [7, 8, 9]])\n",
            "tensor([1, 2, 3, 4, 5, 6, 7, 8, 9])\n",
            "torch.Size([9])\n",
            "tensor([1, 2, 3, 4, 5, 6, 7, 8, 9])\n",
            "tensor([[[1, 2, 3],\n",
            "         [4, 5, 6],\n",
            "         [7, 8, 9]]])\n",
            "tensor([[1, 2, 3],\n",
            "        [4, 5, 6],\n",
            "        [7, 8, 9]])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 행렬 연산"
      ],
      "metadata": {
        "id": "66HNxc-ble2Y"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# xw + b\n",
        " \n",
        "x = torch.tensor([[1, 2], [3, 4], [5, 6]], dtype=torch.float)\n",
        "\n",
        "# randn - 평균이 0 이고, 표준편차가 1인 랜덤 값을 채워줌\n",
        "w = torch.randn(1, 2 ,dtype=torch.float)\n",
        "b = torch.randn(3, 1, dtype=torch.float)\n",
        "\n",
        "print(x)\n",
        "print(w)\n",
        "print(w.type())\n",
        "print(b)\n",
        "\n",
        "\n",
        "# x * w + b\n",
        "# mm = matmul\n",
        "# .T 는 transpose\n",
        "xwp = torch.mm(x, w.T) + b\n",
        "\n",
        "print(xwp)\n",
        "# axis -> 차원, view 로 모양 맞춰줌\n",
        "print((x*w).sum(axis = 1).view(3, 1))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hD08ue23kVCJ",
        "outputId": "5dd62081-216e-4fa5-c9c5-9c5126c6588b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([[1., 2.],\n",
            "        [3., 4.],\n",
            "        [5., 6.]])\n",
            "tensor([[-0.1527,  0.9265]])\n",
            "torch.FloatTensor\n",
            "tensor([[ 0.4697],\n",
            "        [-1.1260],\n",
            "        [ 0.7457]])\n",
            "tensor([[2.1700],\n",
            "        [2.1220],\n",
            "        [5.5413]])\n",
            "tensor([[1.7003],\n",
            "        [3.2479],\n",
            "        [4.7956]])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 기울기 계산"
      ],
      "metadata": {
        "id": "td2vy7fjorZt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#  Autograd: 기울기 계산\n",
        "# - requires_grad 값이 설정된 tensor에 대해서, pytorch는 자동으로 기울기를 계산해 줌\n",
        "\n",
        "# requires_grad를 설정해야 기울기 계산해줌\n",
        "w = torch.tensor(1.0, requires_grad = True) # 1.0에서의 기울기 2.0을 넣으면 36. 이 나옴\n",
        "a = 3 * w\n",
        "l = a** 2\n",
        "l.backward() # 기울기 계산 하자 !\n",
        "print('l을 w로 미분한 값은: ', w.grad) "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cN7gSSDSmi-c",
        "outputId": "08a5f332-83a7-49bb-c9ec-91248d63bfae"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "l을 w로 미분한 값은:  tensor(18.)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#  Linear Regression - 학습 데이터 생성"
      ],
      "metadata": {
        "id": "KwqOqrRavnLz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# y = 2x1 + 3x2 - 4 찾기\n",
        "\n",
        "import torch\n",
        "\n",
        "x_train = torch.tensor([[1,2], [3,2], [3,7], [1,1], [1,0]], dtype=torch.float)\n",
        "# 실제값 y\n",
        "y_train = torch.tensor([[4], [8], [23], [1], [-2]], dtype=torch.float)\n",
        "\n",
        "# W, b 초기화, 기본적으로 zeros는 float타입\n",
        "W = torch.zeros(2, 1)\n",
        "b = torch.zeros(1)\n",
        "\n",
        "print(W)\n",
        "print(b)\n",
        "\n",
        "lr = 0.01 #learning rate\n",
        "\n",
        "for epoch in range(1000):\n",
        "\n",
        "  # W, b 값을 반복해서 업데이트\n",
        "  W.requires_grad_(True)\n",
        "  b.requires_grad_(True)\n",
        "\n",
        "  # 가설 Hypothesis H(x) = wx + b\n",
        "  h = torch.mm(x_train, W) + b\n",
        "  cost = torch.mean((h - y_train) ** 2) # mse <-> 루트까지 씌우면 rmse=torch.mean((h - y) ** 2) ** 0.5 \n",
        "\n",
        "  # cost에 대해서 미분 실행하여 기울기 구함\u001d\n",
        "  cost.backward()\n",
        "\n",
        "  with torch.no_grad(): # 기울기에 전혀 영향을 미치지 않음\n",
        "    W = W - lr * W.grad # 기울기에 lr 곱한 만큼 이동해서 값을 업데이트\n",
        "    b = b - lr * b.grad\n",
        "\n",
        "    if epoch % 100 == 0:\n",
        "      print(f\"W: {W}, b: {b}, cost: {cost}\")\n",
        "    \n"
      ],
      "metadata": {
        "id": "eB3XEju2uiN8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "19258f2a-0fe6-471b-a346-d9eba17834e0"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([[0.],\n",
            "        [0.]])\n",
            "tensor([0.])\n",
            "W: tensor([[0.3840],\n",
            "        [0.7440]]), b: tensor([0.1360]), cost: 122.80000305175781\n",
            "W: tensor([[0.6226],\n",
            "        [3.1603]]), b: tensor([-1.3651]), cost: 1.5337574481964111\n",
            "W: tensor([[0.9143],\n",
            "        [3.1864]]), b: tensor([-2.1790]), cost: 0.7582405805587769\n",
            "W: tensor([[1.2106],\n",
            "        [3.1417]]), b: tensor([-2.7023]), cost: 0.38928839564323425\n",
            "W: tensor([[1.4328],\n",
            "        [3.1025]]), b: tensor([-3.0705]), cost: 0.20005758106708527\n",
            "W: tensor([[1.5932],\n",
            "        [3.0736]]), b: tensor([-3.3338]), cost: 0.10281281173229218\n",
            "W: tensor([[1.7084],\n",
            "        [3.0528]]), b: tensor([-3.5224]), cost: 0.05283750221133232\n",
            "W: tensor([[1.7909],\n",
            "        [3.0378]]), b: tensor([-3.6576]), cost: 0.027154315263032913\n",
            "W: tensor([[1.8501],\n",
            "        [3.0271]]), b: tensor([-3.7546]), cost: 0.01395510695874691\n",
            "W: tensor([[1.8926],\n",
            "        [3.0194]]), b: tensor([-3.8241]), cost: 0.007171782664954662\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 학습이 잘 되는지 확인하기위한 내용 출력\n",
        " \n",
        "x_test = torch.tensor([[5, 10]], dtype=torch.float )\n",
        "test_result = torch.mm(x_test, W) + b\n",
        "\n",
        "print(test_result)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "72iNnN3yyDQa",
        "outputId": "6ce08aa6-9dc8-4095-ede4-122fa6092720"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([[35.8800]])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# LinearRegression with Scikit-learn\n",
        " "
      ],
      "metadata": {
        "id": "jLcFGtKKy3Ft"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.linear_model import LinearRegression\n",
        "\n",
        "x = [[1,2], [3,2], [3,7], [1,1], [1,0]]\n",
        "y = [[4], [8], [23], [1], [-2]]\n",
        "\n",
        "model = LinearRegression()\n",
        "model.fit(x, y)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Xr3kTU0AyhXL",
        "outputId": "a34cff53-d909-4fc6-dcba-9c5d755e1e63"
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "LinearRegression()"
            ]
          },
          "metadata": {},
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#학습 결과 (Parameter) 확인\n",
        "# coef_: 기울기 값 (W에 해당)\n",
        "# intercept_: y절편 값 (b에 해당)\n",
        "\n",
        "print(model.coef_, model.intercept_)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "P1-abB3zy9wU",
        "outputId": "26b20866-8adc-4c8c-93ae-891dee776735"
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[2. 3.]] [-4.]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# y 값 예측하기\n",
        "print(model.predict([[5,10]])) "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZlIth4WE6IDh",
        "outputId": "c50355cc-7d51-42e3-efba-d2c0c6541074"
      },
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[36.]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "-bwwhr_I6gWY"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}