lab07-1_code_Overfitting_and_OverShooting.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Untitled3.ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyNTYj0TSyi+qXgZT3BFN1q5",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/khodid/2020_SAI_MONING2/blob/master/lab07-1_code_Overfitting_and_OverShooting.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MZHI_cFiH4l_",
        "colab_type": "text"
      },
      "source": [
        "## Overfitting 실습\n",
        "모델이 Training set에 대해 과적합되어, 새로운 데이터인 Test Set에는 적용되지 못하는 현상을 관찰해보겠다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_y90mrVSNvK_",
        "colab_type": "text"
      },
      "source": [
        "####Imports"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VpRnvBa6HtWT",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "b0e0b90b-077f-42ca-a78b-7f9c4901b82b"
      },
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "import torch.optim as optim\n",
        "\n",
        "# For reproductibitily\n",
        "torch.manual_seed(1)"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<torch._C.Generator at 0x7f85c45fc750>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gQgaHqkrI7E5",
        "colab_type": "text"
      },
      "source": [
        "#### Training Set과 Testing Set 나누어서 선언해줌"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jeEKUke5JADl",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "x_train = torch.FloatTensor([[1, 2, 1],\n",
        "                            [1, 3, 2],\n",
        "                            [1, 3, 4],\n",
        "                            [1, 5, 5],\n",
        "                            [1, 7, 5],\n",
        "                            [1, 2, 5],\n",
        "                            [1, 6, 6],\n",
        "                            [1, 7, 7]])\n",
        "# |x_train| = (m, 3)\n",
        "\n",
        "y_train = torch.LongTensor([2, 2, 2, 1, 1, 1, 0, 0])\n",
        "# |y_train| = (m,  ) One Hot Vector의 인덱스들을 가지고 있음 \n",
        "\n",
        "x_test = torch.FloatTensor([[2, 1, 1], [3, 1, 2], [3, 3, 4]])\n",
        "# |x_test| = (m', 3)    x_train과 feature 수가 같아야 하므로 똑같이 3\n",
        "\n",
        "y_test = torch.LongTensor([2, 2, 2])\n",
        "# |y_test| = (m',  )\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VIwbgd0SJC6G",
        "colab_type": "text"
      },
      "source": [
        "####모델 설정. \n",
        "이전에 배웠던 Softmax Regression용 모듈을 적용한다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZGMw2nfHJKTT",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class SoftmaxClassifierModel(nn.Module):\n",
        "  def __init__(self):\n",
        "    super().__init__()\n",
        "    self.linear = nn.Linear(3, 3)\n",
        "    \n",
        "  def forward(self, x):\n",
        "    return self.linear(x)\n",
        "\n",
        "model = SoftmaxClassifierModel()\n",
        "\n",
        "# optimizer 설정\n",
        "optimizer = optim.SGD(model.parameters(), lr = 0.1)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MfiFNbhNJP00",
        "colab_type": "text"
      },
      "source": [
        "####  관찰하기\n",
        "Training Set에 대해 위 모듈을 적용해 모델을 학습시키는 함수를 만든다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NwVmVk-MJXbl",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Training data에 대해 Seftmax Regression을 20회에 걸쳐 수행하고 결과 출력하는 함수\n",
        "def train(model, optimizer, x_train, y_train) : \n",
        "  nb_epochs = 20;\n",
        "  for epoch in range (nb_epochs):\n",
        "\n",
        "    # H(x) 계산\n",
        "    prediction = model(x_train)   # |prediction| = |x_train| = (m, 3)\n",
        "\n",
        "\n",
        "    # cost 계산\n",
        "    cost = F.cross_entropy(prediction, y_train)\n",
        "\n",
        "    # cost로 H(x) 계산\n",
        "\n",
        "    optimizer.zero_grad()\n",
        "    cost.backward()\n",
        "    optimizer.step()\n",
        "\n",
        "    print('E: {:4d}/{}  Cost: {:.6f}'.format(epoch, nb_epochs, cost.item()))\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ma11N8FnJiQ3",
        "colab_type": "text"
      },
      "source": [
        "Test를 통해 Accuracy를 구하는 함수도 만들어준다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yxd0GHbNJoc5",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def test(model, opt, x_test, y_test):\n",
        "  prediction = model(x_test)                  # model을 test set에 통과시킴. |x_test| = (m',3)\n",
        "  predicted_classes = prediction.max(1)[1]    # |prediction| = (m',3)\n",
        "  # max 함수는 입력된 dimention의 방향에 맞는 최대값을 구해주는 함수였던 것 같다..\n",
        "  correct_count = (predicted_classes == y_test).sum().item()\n",
        "  cost = F.cross_entropy(prediction, y_test)  # 정답과의 cross entropy를 구한다.\n",
        "\n",
        "  print('Accuracy: {}%   Cost: {:.6f}'.format(correct_count / len(y_test) * 100, cost.item()))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VL8HltrZJrUM",
        "colab_type": "text"
      },
      "source": [
        "함수를 호출해 작동시키고, 결과를 지켜 본다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1JE13lEZJu-G",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 386
        },
        "outputId": "20fcca60-6919-4bee-c49e-64216a1226b6"
      },
      "source": [
        "train(model, optimizer, x_train, y_train)\n",
        "test(model, optimizer, x_test, y_test)"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "E:    0/20  Cost: 2.203667\n",
            "E:    1/20  Cost: 1.199645\n",
            "E:    2/20  Cost: 1.142985\n",
            "E:    3/20  Cost: 1.117769\n",
            "E:    4/20  Cost: 1.100901\n",
            "E:    5/20  Cost: 1.089523\n",
            "E:    6/20  Cost: 1.079872\n",
            "E:    7/20  Cost: 1.071320\n",
            "E:    8/20  Cost: 1.063325\n",
            "E:    9/20  Cost: 1.055720\n",
            "E:   10/20  Cost: 1.048378\n",
            "E:   11/20  Cost: 1.041245\n",
            "E:   12/20  Cost: 1.034285\n",
            "E:   13/20  Cost: 1.027478\n",
            "E:   14/20  Cost: 1.020813\n",
            "E:   15/20  Cost: 1.014279\n",
            "E:   16/20  Cost: 1.007872\n",
            "E:   17/20  Cost: 1.001586\n",
            "E:   18/20  Cost: 0.995419\n",
            "E:   19/20  Cost: 0.989365\n",
            "Accuracy: 0.0%   Cost: 1.425844\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ASrVa9jjMF_e",
        "colab_type": "text"
      },
      "source": [
        "위 결과에서 Trainig Set에 대한 Cost는 점차 낮아지는 것을 관찰 할 수 있으나,\n",
        "Test Set에 대한 Cost는 외려 다소 큰 것을 볼 수 있다.\n",
        "20 Epoch에 도달했을 지점엔 이미 overfitting이 진행되었다는 걸 알 수 있다. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QjplYGljNLnH",
        "colab_type": "text"
      },
      "source": [
        "## Learning Rate\n",
        "\n",
        "이번에는 Gradient Descent에서 learning rate을 너무 **크게** 잡았을 때 overshooting 하는 모습을 관찰해보겠다.\n",
        "\n",
        "lr을 e의 5승(대략 148.4)으로 잡았다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3OGWsDTHOC1Z",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 369
        },
        "outputId": "76e77d66-a9c0-4ff3-c979-d4742cfef5f4"
      },
      "source": [
        "model = SoftmaxClassifierModel()\n",
        "optimizer = optim.SGD(model.parameters(), lr = 1e5)\n",
        "train(model, optimizer, x_train, y_train)"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "E:    0/20  Cost: 1.280268\n",
            "E:    1/20  Cost: 976950.750000\n",
            "E:    2/20  Cost: 1279135.000000\n",
            "E:    3/20  Cost: 1198379.125000\n",
            "E:    4/20  Cost: 1098825.625000\n",
            "E:    5/20  Cost: 1968197.625000\n",
            "E:    6/20  Cost: 284763.125000\n",
            "E:    7/20  Cost: 1532260.000000\n",
            "E:    8/20  Cost: 1651504.250000\n",
            "E:    9/20  Cost: 521878.437500\n",
            "E:   10/20  Cost: 1397263.125000\n",
            "E:   11/20  Cost: 750986.250000\n",
            "E:   12/20  Cost: 918691.750000\n",
            "E:   13/20  Cost: 1487888.125000\n",
            "E:   14/20  Cost: 1582260.125000\n",
            "E:   15/20  Cost: 685818.000000\n",
            "E:   16/20  Cost: 1140048.750000\n",
            "E:   17/20  Cost: 940566.750000\n",
            "E:   18/20  Cost: 931638.125000\n",
            "E:   19/20  Cost: 1971322.625000\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "34ydVN8POiPP",
        "colab_type": "text"
      },
      "source": [
        "이번에는 Learning rate이 너무 작을 때 cost 값이 잘 줄어들지 않는 것을 관찰하겠다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Q2owj_ccPwxN",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 369
        },
        "outputId": "98935a75-f7e5-427b-c556-0f801f578dfe"
      },
      "source": [
        "model = SoftmaxClassifierModel()\n",
        "optimizer = optim.SGD(model.parameters(), lr = 1e-10)\n",
        "train(model, optimizer, x_train, y_train)"
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "E:    0/20  Cost: 3.187324\n",
            "E:    1/20  Cost: 3.187324\n",
            "E:    2/20  Cost: 3.187324\n",
            "E:    3/20  Cost: 3.187324\n",
            "E:    4/20  Cost: 3.187324\n",
            "E:    5/20  Cost: 3.187324\n",
            "E:    6/20  Cost: 3.187324\n",
            "E:    7/20  Cost: 3.187324\n",
            "E:    8/20  Cost: 3.187324\n",
            "E:    9/20  Cost: 3.187324\n",
            "E:   10/20  Cost: 3.187324\n",
            "E:   11/20  Cost: 3.187324\n",
            "E:   12/20  Cost: 3.187324\n",
            "E:   13/20  Cost: 3.187324\n",
            "E:   14/20  Cost: 3.187324\n",
            "E:   15/20  Cost: 3.187324\n",
            "E:   16/20  Cost: 3.187324\n",
            "E:   17/20  Cost: 3.187324\n",
            "E:   18/20  Cost: 3.187324\n",
            "E:   19/20  Cost: 3.187324\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cy2lpuMpQPTr",
        "colab_type": "text"
      },
      "source": [
        "아무튼 이렇게 학습이 발산을 하거나, 너무 더디게 진행될 경우 lr을 조절해주는 노하우가 필요하다. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gSzZqjxAQgWw",
        "colab_type": "text"
      },
      "source": [
        "## Data Preprocessing\n",
        "\n",
        "데이터 전처리(선처리)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FHVVfWzMQY8j",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "x_train  = torch.FloatTensor([[73, 80, 75],\n",
        "                             [93, 88, 93],\n",
        "                             [89, 91, 90],\n",
        "                             [96, 98, 100],\n",
        "                             [73, 66, 70]])\n",
        "y_train  = torch.FloatTensor([[152],[185],[180], [196], [142]])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PiwowcUJRE3H",
        "colab_type": "text"
      },
      "source": [
        "Mean Square Error 값을 쓰게 될 것임.\n",
        "\n",
        "아래 코드는 x_train 벡터들을 Normalization 시키는 과정이다.\n",
        "\n",
        "방법 - Standardization; 정규화\n",
        "\n",
        "$$ \n",
        "x'_j = \\frac{x_j - \\mu_j}{\\sigma_j}\n",
        "$$"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nYrFvfUGRKsy",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 105
        },
        "outputId": "3ac5be9f-f305-4d2d-b908-bdf73259ae53"
      },
      "source": [
        "mu = x_train.mean(dim=0)\n",
        "sigma = x_train.std(dim=0)\n",
        "norm_x_train = (x_train - mu)/sigma\n",
        "\n",
        "print(norm_x_train)"
      ],
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "tensor([[-1.0674, -0.3758, -0.8398],\n",
            "        [ 0.7418,  0.2778,  0.5863],\n",
            "        [ 0.3799,  0.5229,  0.3486],\n",
            "        [ 1.0132,  1.0948,  1.1409],\n",
            "        [-1.0674, -1.5197, -1.2360]])\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mRf1ZA55R09p",
        "colab_type": "text"
      },
      "source": [
        "정규 분포를 따르는 training set을 만들어 주었다.\n",
        "\n",
        "\n",
        "그 이후엔 데이터에 맞게 regression 모델을 짜주겠다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WrWxz4rnSMKn",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class MultivariableLinearRegressionModel(nn.Module):\n",
        "  def __init__(self):\n",
        "    super().__init__()\n",
        "    self.linear = nn.Linear(3, 1)\n",
        "\n",
        "  def forward(self, x):\n",
        "    return self.linear(x)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ll7Umv1tSruh",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "model = MultivariableLinearRegressionModel()\n",
        "optimizer = optim.SGD(model.parameters(), lr = 1e-1)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Lx6-GxV6TjUM",
        "colab_type": "text"
      },
      "source": [
        "Training 함수 짜기"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "e8ajtI_FS-Dx",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Training \n",
        "\n",
        "def train(model, optimizer, x_train, y_train):\n",
        "  nb_epochs = 20\n",
        "  for epoch in range(nb_epochs):\n",
        "    \n",
        "    # H(x) 계산\n",
        "    prediction = model(x_train)          \n",
        "    # |x_train| = (m, 3)\n",
        "    # |prediction| = (m, 1)\n",
        "\n",
        "    # Cost는 MSE로 계산\n",
        "    cost = F.mse_loss(prediction, y_train)\n",
        "    # cost를 토대로 H(x) 개선\n",
        "    optimizer.zero_grad()\n",
        "    cost.backward()\n",
        "    optimizer.step()\n",
        "\n",
        "    print('E: {:4d} / {}   Cost: {:.6f} '.format(epoch, nb_epochs, cost.item()))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4yxbvd36UQct",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 756
        },
        "outputId": "cc3ebafe-d9b7-4fdd-d823-3bb03a5a4975"
      },
      "source": [
        "print(\"*** Training with Preprocessed Data\")\n",
        "train(model, optimizer, norm_x_train, y_train)\n",
        "\n",
        "print(\"*** Without data Preprocessing... \")\n",
        "model = MultivariableLinearRegressionModel()\n",
        "optimizer = optim.SGD(model.parameters(), lr = 1e-1)\n",
        "train(model, optimizer, x_train, y_train)"
      ],
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "*** Training with Preprocessed Data\n",
            "E:    0 / 20   Cost: 29615.740234 \n",
            "E:    1 / 20   Cost: 18803.878906 \n",
            "E:    2 / 20   Cost: 11991.029297 \n",
            "E:    3 / 20   Cost: 7661.868164 \n",
            "E:    4 / 20   Cost: 4900.236816 \n",
            "E:    5 / 20   Cost: 3135.413574 \n",
            "E:    6 / 20   Cost: 2006.681396 \n",
            "E:    7 / 20   Cost: 1284.504639 \n",
            "E:    8 / 20   Cost: 822.366089 \n",
            "E:    9 / 20   Cost: 526.605774 \n",
            "E:   10 / 20   Cost: 337.314728 \n",
            "E:   11 / 20   Cost: 216.160767 \n",
            "E:   12 / 20   Cost: 138.613449 \n",
            "E:   13 / 20   Cost: 88.974701 \n",
            "E:   14 / 20   Cost: 57.197395 \n",
            "E:   15 / 20   Cost: 36.851803 \n",
            "E:   16 / 20   Cost: 23.822887 \n",
            "E:   17 / 20   Cost: 15.476827 \n",
            "E:   18 / 20   Cost: 10.128090 \n",
            "E:   19 / 20   Cost: 6.697937 \n",
            "*** Without data Preprocessing... \n",
            "E:    0 / 20   Cost: 57621.976562 \n",
            "E:    1 / 20   Cost: 1115690762240.000000 \n",
            "E:    2 / 20   Cost: 21603378185380036608.000000 \n",
            "E:    3 / 20   Cost: 418311281336289389130547200.000000 \n",
            "E:    4 / 20   Cost: 8099858389234773491298680935809024.000000 \n",
            "E:    5 / 20   Cost: inf \n",
            "E:    6 / 20   Cost: inf \n",
            "E:    7 / 20   Cost: inf \n",
            "E:    8 / 20   Cost: inf \n",
            "E:    9 / 20   Cost: inf \n",
            "E:   10 / 20   Cost: inf \n",
            "E:   11 / 20   Cost: inf \n",
            "E:   12 / 20   Cost: nan \n",
            "E:   13 / 20   Cost: nan \n",
            "E:   14 / 20   Cost: nan \n",
            "E:   15 / 20   Cost: nan \n",
            "E:   16 / 20   Cost: nan \n",
            "E:   17 / 20   Cost: nan \n",
            "E:   18 / 20   Cost: nan \n",
            "E:   19 / 20   Cost: nan \n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JJG2pQXeVLtY",
        "colab_type": "text"
      },
      "source": [
        "normalization이 필요한 데이터셋은 어떤 걸까?\n",
        "\\|y_train\\|이 (m, 2)와 같이 2차원 prediction 구조를 가질 때, 두 colomn 사이의 수의 스케일이 서로 다르다면 training 모델은 더 큰 값에만 집중을 하게 된다.\n",
        "\n",
        "전처리를 수행하게 되면 똑같은 범위의 값으로 바뀔 것이고, 모델은 두가지 데이터에 대해 공정하게 학습을 할 수 있을 것이다."
      ]
    }
  ]
}