3.다중 분류 (Multi-Class Classification).ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Untitled3.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Rd0RDB6_mF2f",
        "colab_type": "text"
      },
      "source": [
        "# Multi-Class Classification\n",
        "클래스가 3개 이상인 경우 Softmax 함수를 이용하여 분류"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MfqKrtLBmFSz",
        "colab_type": "text"
      },
      "source": [
        "## Load Data"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "crftV5RUyMWg",
        "colab_type": "code",
        "outputId": "4fd9fc05-ab7b-4e9d-f6d2-34c63b6409de",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 122
        }
      },
      "source": [
        "import torch\n",
        "import torch.optim as optim\n",
        "\n",
        "torch.manual_seed(1)\n",
        "\n",
        "x_train = [[1, 2, 1, 1],\n",
        "           [2, 1, 3, 2],\n",
        "           [3, 1, 3, 4],\n",
        "           [4, 1, 5, 5],\n",
        "           [1, 7, 5, 5],\n",
        "           [1, 2, 5, 6],\n",
        "           [1, 6, 6, 6],\n",
        "           [1, 7, 7, 7]]\n",
        "y_train = [2, 2, 2, 1, 1, 1, 0, 0]\n",
        "\n",
        "x_train = torch.FloatTensor(x_train)\n",
        "y_train = torch.LongTensor(y_train)\n",
        "\n",
        "print(x_train[:5])\n",
        "print(y_train[:5])"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "tensor([[1., 2., 1., 1.],\n",
            "        [2., 1., 3., 2.],\n",
            "        [3., 1., 3., 4.],\n",
            "        [4., 1., 5., 5.],\n",
            "        [1., 7., 5., 5.]])\n",
            "tensor([2, 2, 2, 1, 1])\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e23GdH-xYftA",
        "colab_type": "text"
      },
      "source": [
        "## one-hot encoding"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "miaw_JqdbsWd",
        "colab_type": "code",
        "outputId": "b36a3684-b581-4ce4-b0c3-590b9ed37068",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 351
        }
      },
      "source": [
        "print(y_train)\n",
        "print(y_train.shape)\n",
        "print(y_train.unsqueeze(1)) # unsqueeze 함수는 인수로 받은 위치에 새로운 차원을 삽입한다.\n",
        "print(y_train.unsqueeze(1).shape)\n",
        "\n",
        "nb_class = 3\n",
        "nb_data = len(y_train)\n",
        "y_one_hot = torch.zeros(nb_data, nb_class)\n",
        "y_one_hot.scatter_(1, y_train.unsqueeze(1), 1)  # scatter(a,b,c): dimension a 에 대해 b에서 지정한 위치에 c 삽입\n",
        "                                                # 언더바(_)를 함수뒤에 붙이면 in-place operation, 바꿔치기 연산이 되는데, 연산의 결과를 바로 y_one_hot에 저장하는 것이다.\n",
        "                                                # (y_one_hot = y_one_hot.scatter.... 할 필요없이)\n",
        "\n",
        "print(y_one_hot)"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "tensor([2, 2, 2, 1, 1, 1, 0, 0])\n",
            "torch.Size([8])\n",
            "tensor([[2],\n",
            "        [2],\n",
            "        [2],\n",
            "        [1],\n",
            "        [1],\n",
            "        [1],\n",
            "        [0],\n",
            "        [0]])\n",
            "torch.Size([8, 1])\n",
            "tensor([[0., 0., 1.],\n",
            "        [0., 0., 1.],\n",
            "        [0., 0., 1.],\n",
            "        [0., 1., 0.],\n",
            "        [0., 1., 0.],\n",
            "        [0., 1., 0.],\n",
            "        [1., 0., 0.],\n",
            "        [1., 0., 0.]])\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OTerh5sZo69T",
        "colab_type": "text"
      },
      "source": [
        "## Train Model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GHSZppOfyp-n",
        "colab_type": "code",
        "outputId": "84ef90d7-5661-4fe4-c255-f2c44d7b279a",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 210
        }
      },
      "source": [
        "import torch.nn.functional as F # softmax가 포함된 클래스\n",
        "\n",
        "W = torch.zeros((4, nb_class), requires_grad=True) # 3개의 클래스에 대한 4개의 Feature별 가중치\n",
        "b = torch.zeros(nb_class, requires_grad=True) # 편향은 하나만 써도 되고 클래스 갯수만큼 써도 됨\n",
        "\n",
        "# optimizer 설정\n",
        "optimizer = optim.SGD([W, b], lr=0.01)\n",
        "nb_epochs = 1000\n",
        "for epoch in range(nb_epochs + 1):\n",
        "\n",
        "    # Cost 계산 (1)\n",
        "    hypothesis = F.softmax(x_train.matmul(W) + b, dim=1) # or .mm or @\n",
        "    \n",
        "    # cost 표현번 1번 예시\n",
        "    # one-hot 인코딩이 되어있고, Cross Entropy를 직접 구현\n",
        "    cost = (y_one_hot * -torch.log(hypothesis)).sum(dim=1).mean()\n",
        "    \n",
        "    # cost 표현법 2번 예시\n",
        "    # torch.nn.functional에 포함된 cross entropy 사용\n",
        "    # F.cross_entropy를 사용하면 scatter 함수를 이용한 one_hot_encoding을 안해도 됨\n",
        "    # cost = F.cross_entropy((x_train.matmul(W) + b), y_train)\n",
        "\n",
        "    # cost로 H(x) 개선\n",
        "    optimizer.zero_grad()\n",
        "    cost.backward()\n",
        "    optimizer.step()\n",
        "\n",
        "    # 100번마다 로그 출력\n",
        "    if epoch % 100 == 0:\n",
        "        print('Epoch {:4d}/{} Cost: {:.6f}'.format(\n",
        "            epoch, nb_epochs, cost.item()\n",
        "        ))"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch    0/1000 Cost: 1.098612\n",
            "Epoch  100/1000 Cost: 0.825978\n",
            "Epoch  200/1000 Cost: 0.745367\n",
            "Epoch  300/1000 Cost: 0.695094\n",
            "Epoch  400/1000 Cost: 0.658135\n",
            "Epoch  500/1000 Cost: 0.629088\n",
            "Epoch  600/1000 Cost: 0.605386\n",
            "Epoch  700/1000 Cost: 0.585531\n",
            "Epoch  800/1000 Cost: 0.568553\n",
            "Epoch  900/1000 Cost: 0.553787\n",
            "Epoch 1000/1000 Cost: 0.540759\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QixkNjHgpwHM",
        "colab_type": "text"
      },
      "source": [
        "## Evaluate Model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QFcRqSOtyxNR",
        "colab_type": "code",
        "outputId": "03ca8640-01c0-4107-a7bc-9c4d8efefc57",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 228
        }
      },
      "source": [
        "# 학습된 W,b를 통한 클래스 예측\n",
        "hypothesis = F.softmax(x_train.matmul(W) + b, dim=1) # or .mm or @\n",
        "predict = torch.argmax(hypothesis, dim=1) # 가장 큰 값의 인덱스 출력\n",
        "\n",
        "print(hypothesis)\n",
        "print(predict)\n",
        "print(y_train)\n",
        "\n",
        "\n",
        "# 정확도 계산 \n",
        "correct_prediction = predict.float() == y_train\n",
        "print(correct_prediction)\n",
        "accuracy = correct_prediction.sum().item() / len(correct_prediction)\n",
        "print('The model has an accuracy of {:2.2f}% for the training set.'.format(accuracy * 100))"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "tensor([[0.0808, 0.1519, 0.7673],\n",
            "        [0.0561, 0.2938, 0.6502],\n",
            "        [0.0169, 0.4154, 0.5677],\n",
            "        [0.0107, 0.5506, 0.4387],\n",
            "        [0.6195, 0.3130, 0.0675],\n",
            "        [0.2591, 0.7232, 0.0178],\n",
            "        [0.5794, 0.3999, 0.0206],\n",
            "        [0.6471, 0.3453, 0.0075]], grad_fn=<SoftmaxBackward>)\n",
            "tensor([2, 2, 2, 1, 0, 1, 0, 0], grad_fn=<NotImplemented>)\n",
            "tensor([2, 2, 2, 1, 1, 1, 0, 0])\n",
            "tensor([ True,  True,  True,  True, False,  True,  True,  True])\n",
            "The model has an accuracy of 87.50% for the training set.\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}