02_파이토치_기초.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "02.파이토치 기초.ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyMqmi6SuSizG0YLeWsEHNIa",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/threegenie/studying_pytorch/blob/main/02_%ED%8C%8C%EC%9D%B4%ED%86%A0%EC%B9%98_%EA%B8%B0%EC%B4%88.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dyqpzEQRxBSY"
      },
      "source": [
        "> 1D with Numpy"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "psLTEYnCuwef"
      },
      "source": [
        "import numpy as np"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jQgNMf5Qw5cy"
      },
      "source": [
        "t = np.array([0,1,2,3,4,5,6])"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7EZhMMmExAiR",
        "outputId": "0824ac6d-9569-4c69-dde2-0916e709e18f"
      },
      "source": [
        "print('벡터의 차원 : ',t.ndim)"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "벡터의 차원 :  1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MGt9U-BzxKsk",
        "outputId": "c3ef3347-87dd-4d5c-be65-e480fd38e447"
      },
      "source": [
        "print('벡터의 크기 : ',t.shape)"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "벡터의 크기 :  (7,)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O6igNzhBxRWz"
      },
      "source": [
        "(7,) = (1,7) = 1 x 7의 크기를 가지는 벡터"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4k7gjlrIxdKZ"
      },
      "source": [
        "> 파이토치 텐서 선언"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FxbwEVg5xf3H"
      },
      "source": [
        "import torch"
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kUfyKb7qxilg"
      },
      "source": [
        "te = torch.IntTensor([0,1,2,3,4,5,6])"
      ],
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7IWw6iyVxyWR"
      },
      "source": [
        "실수로 만드려면 torch.FloatTensor"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YK47GyN-xrL3",
        "outputId": "ee37ce48-358e-49fa-8bb6-1085d352daf9"
      },
      "source": [
        "print(te.dim())  # rank. 즉, 차원\n",
        "print(te.shape)  # shape\n",
        "print(te.size()) # shape"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "torch.Size([7])\n",
            "torch.Size([7])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ebHi11GQx6zT",
        "outputId": "19729af3-f622-47ec-b4f9-13cc6dc32a75"
      },
      "source": [
        "print(te[0], te[1], te[-1])  # 인덱스로 접근\n",
        "print(te[2:5], te[4:-1])    # 슬라이싱\n",
        "print(te[:2], te[3:])       # 슬라이싱"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor(0, dtype=torch.int32) tensor(1, dtype=torch.int32) tensor(6, dtype=torch.int32)\n",
            "tensor([2, 3, 4], dtype=torch.int32) tensor([4, 5], dtype=torch.int32)\n",
            "tensor([0, 1], dtype=torch.int32) tensor([3, 4, 5, 6], dtype=torch.int32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YmsB1ijlyJZ7"
      },
      "source": [
        "> 2D 텐서 만들기"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ztlOcvJfyMhm",
        "outputId": "2ee3b34e-5e82-4021-8d29-022132e2d808"
      },
      "source": [
        "t = torch.FloatTensor([[1., 2., 3.],\n",
        "                       [4., 5., 6.],\n",
        "                       [7., 8., 9.],\n",
        "                       [10., 11., 12.]\n",
        "                      ])\n",
        "print(t)"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([[ 1.,  2.,  3.],\n",
            "        [ 4.,  5.,  6.],\n",
            "        [ 7.,  8.,  9.],\n",
            "        [10., 11., 12.]])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pBHeArVPyPf2",
        "outputId": "76cd2a7c-47d1-4aed-9bae-2e61bb6061dd"
      },
      "source": [
        "print(t.dim())  # rank. 즉, 차원\n",
        "print(t.size()) # shape"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2\n",
            "torch.Size([4, 3])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JZUftiH_yVLn",
        "outputId": "c63d71ce-f85f-449b-d034-a6c573389802"
      },
      "source": [
        "print(t[:, 1]) # 첫번째 차원을 전체 선택한 상황에서 두번째 차원의 첫번째 것만 가져온다.\n",
        "print(t[:, 1].size()) # ↑ 위의 경우의 크기"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([ 2.,  5.,  8., 11.])\n",
            "torch.Size([4])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7nk5Dk0UyXfJ"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YqdjkgGuyYXG",
        "outputId": "0aa1318f-c232-4b40-8b98-2bbd1782744b"
      },
      "source": [
        "t = torch.IntTensor([[1, 2, 3],\n",
        "                       [4, 5, 6],\n",
        "                       [7, 8, 9],\n",
        "                       [10, 11, 12]\n",
        "                      ])\n",
        "print(t)"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([[ 1,  2,  3],\n",
            "        [ 4,  5,  6],\n",
            "        [ 7,  8,  9],\n",
            "        [10, 11, 12]], dtype=torch.int32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QiMe0zZ_yka7",
        "outputId": "6275dd05-f309-49df-c0eb-38e088c08eb2"
      },
      "source": [
        "print(t.dim())  # rank. 즉, 차원\n",
        "print(t.size()) # shape"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2\n",
            "torch.Size([4, 3])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "skAHicrnylNi",
        "outputId": "0d6ba96c-0db0-4a72-854a-de0f3e687b2f"
      },
      "source": [
        "print(t[:, 1]) # 첫번째 차원을 전체 선택한 상황에서 두번째 차원의 첫번째 것만 가져온다.\n",
        "print(t[:, 1].size()) # ↑ 위의 경우의 크기"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([ 2,  5,  8, 11], dtype=torch.int32)\n",
            "torch.Size([4])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nmHgdHZ_ynw2"
      },
      "source": [
        "tensor를 float와 int로 선언한 것을 비교하면, int로 선언하면 tensor를 슬라이싱하거나 그대로 출력할 때 데이터 타입이 붙는다. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1Tm3YutVzCZB"
      },
      "source": [
        "- 관련해서 추가 정리\n",
        "\n",
        "```\n",
        "텐서는 각 데이터 형태별로 정의되어 있습니다.\n",
        "torch.FloatTensor : 32bit float point\n",
        "torch.LongTensor : 64bit signed integer\n",
        "GPU 상에서 계산할 때에는 torch.cuda.FloatTensor를 사용합니다. 일반적으로 Tensor는 FloatTensor라고 생각하면 됩니다.\n",
        "어떤 형태의 텐서이건 torch.tensor라는 함수로 작성할 수 있습니다.\n",
        "텐서에서의 사칙연산은 같은 타입의 텐서 간 또는 텐서와 파이썬의 스칼라 값 사이에서만 가능합니다.\n",
        "텐서간이라도 타입이 다르면 연산이 되지 않습니다. FloatTensor와 DoubleTensor간의 사칙연산은 오류가 발생합니다.\n",
        "```\n",
        "https://gaussian37.github.io/dl-pytorch-basic/\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LTI4Mw6vzy7T"
      },
      "source": [
        "> 브로드캐스팅"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ec5bLhaYzv4F"
      },
      "source": [
        "m1 = torch.FloatTensor([[3, 3]])\n",
        "m2 = torch.FloatTensor([[2, 2]])"
      ],
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YCwZ58fez3BI",
        "outputId": "12033cce-e21c-426e-bccd-2ce8895b291a"
      },
      "source": [
        "print(m1 + m2)"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([[5., 5.]])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "h9pb377rz7bf",
        "outputId": "f6d0e755-ea2b-4b25-8ec2-8bcde1163f25"
      },
      "source": [
        "# Vector + scalar\n",
        "m1 = torch.FloatTensor([[1, 2]])\n",
        "m2 = torch.FloatTensor([3]) # [3] -> [3, 3]\n",
        "print(m1 + m2)"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([[4., 5.]])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "p52LNJmGQOzQ",
        "outputId": "053d152a-f174-44c3-d586-33e7ca82b2d9"
      },
      "source": [
        "# 2 x 1 Vector + 1 x 2 Vector\n",
        "m1 = torch.FloatTensor([[1, 2]])\n",
        "m2 = torch.FloatTensor([[3], [4]])\n",
        "print(m1 + m2)"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([[4., 5.],\n",
            "        [5., 6.]])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UFUd-V2UQVGz"
      },
      "source": [
        "\n",
        "\n",
        "```\n",
        "# 브로드캐스팅 과정에서 실제로 두 텐서가 어떻게 변경되는지 보겠습니다.\n",
        "[1, 2]\n",
        "==> [[1, 2],\n",
        "     [1, 2]]\n",
        "[3]\n",
        "[4]\n",
        "==> [[3, 3],\n",
        "     [4, 4]]\n",
        "```\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KZ1exGlbUgnO"
      },
      "source": [
        "> 곱셈"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uuT21kefQcYR",
        "outputId": "0aa02a10-a06b-4281-d7aa-fc1f23affc4a"
      },
      "source": [
        "# 행렬 곱셈 - .matmul\n",
        "m1 = torch.FloatTensor([[1, 2], [3, 4]])\n",
        "m2 = torch.FloatTensor([[1], [2]])\n",
        "\n",
        "print(m1.matmul(m2)) # 2 x 1"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([[ 5.],\n",
            "        [11.]])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GKIWLMrOUtvH",
        "outputId": "a733cbb6-b35b-4019-b8ee-8085e8c65845"
      },
      "source": [
        "# 원소별 곱셈  - .mul\n",
        "m1 = torch.FloatTensor([[1, 2], [3, 4]])\n",
        "m2 = torch.FloatTensor([[1], [2]])\n",
        "\n",
        "print(m1 * m2) # 2 x 2\n",
        "\n",
        "print(m1.mul(m2))"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([[1., 2.],\n",
            "        [6., 8.]])\n",
            "tensor([[1., 2.],\n",
            "        [6., 8.]])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "esNVnymxU-rT"
      },
      "source": [
        "> 평균"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yr6mAgioVAIb",
        "outputId": "9e6a4084-d44b-43af-b0b6-24c9f70c6292"
      },
      "source": [
        "# 평균 - .mean\n",
        "t = torch.FloatTensor([1, 2])\n",
        "print(t.mean())"
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor(1.5000)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Bfy9U62fVHYI",
        "outputId": "70e6c1f3-242e-4d89-814d-1644555dd256"
      },
      "source": [
        "t = torch.FloatTensor([[1, 2], [3, 4]])\n",
        "print(t.mean())"
      ],
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor(2.5000)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oQnu0yeHVLTE",
        "outputId": "fd282ed6-38c9-48ee-fd36-62aac750be19"
      },
      "source": [
        "print(t.mean(dim=0))"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([2., 3.])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UX7ZDOm5VQ4g"
      },
      "source": [
        "\n",
        "\n",
        "```\n",
        "# 실제 연산 과정\n",
        "t.mean(dim=0)은 입력에서 첫번째 차원을 제거한다.\n",
        "\n",
        "[[1., 2.],\n",
        " [3., 4.]]\n",
        "\n",
        "1과 3의 평균을 구하고, 2와 4의 평균을 구한다.\n",
        "결과 ==> [2., 3.]\n",
        "```\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EZn7mJDuVV0E",
        "outputId": "22684283-6727-4338-cc01-785339a5ddab"
      },
      "source": [
        "print(t.mean(dim=1))"
      ],
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([1.5000, 3.5000])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UwpNXVrBVqFF"
      },
      "source": [
        "\n",
        "\n",
        "```\n",
        "# 실제 연산 결과는 (2 × 1)\n",
        "[1. 5]\n",
        "[3. 5]\n",
        "```\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aXwjKinuUh2p"
      },
      "source": [
        "> 덧셈"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uE3ilU5TUjX1",
        "outputId": "05d1ee26-3c1b-4e6e-88b7-ff366ccc1055"
      },
      "source": [
        "# 덧셈 - .sum\n",
        "t = torch.FloatTensor([[1, 2], [3, 4]])\n",
        "print(t)"
      ],
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([[1., 2.],\n",
            "        [3., 4.]])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "I8ru1FGBWhQj",
        "outputId": "54b66db0-9a21-4c76-f51b-857009f0e395"
      },
      "source": [
        "print(t.sum()) # 단순히 원소 전체의 덧셈을 수행\n",
        "print(t.sum(dim=0)) # 행을 제거\n",
        "print(t.sum(dim=1)) # 열을 제거\n",
        "print(t.sum(dim=-1)) # 열을 제거"
      ],
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor(10.)\n",
            "tensor([4., 6.])\n",
            "tensor([3., 7.])\n",
            "tensor([3., 7.])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kKnOHzsPUjxg"
      },
      "source": [
        "> 최대, 아그맥스"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WhhnrCpYUl8Q",
        "outputId": "eb7c7ed5-398a-4746-b4c8-34ff1d37c957"
      },
      "source": [
        "# 최대 - 원소의 최대값 리턴\n",
        "# 아그맥스 - 최대값 가진 인덱스 리턴\n",
        "\n",
        "t = torch.FloatTensor([[1, 2], [3, 4]])\n",
        "print(t)"
      ],
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([[1., 2.],\n",
            "        [3., 4.]])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YwwN3m8mXBRI",
        "outputId": "6affe098-d095-4989-b0b6-3238e9fd0836"
      },
      "source": [
        "print('Max: ', t.max(dim=0)[0])\n",
        "print('Argmax: ', t.max(dim=0)[1])"
      ],
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Max:  tensor([3., 4.])\n",
            "Argmax:  tensor([1, 1])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mTrGdLJfXPnN"
      },
      "source": [
        "> 뷰(View) "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TbwpjP5mXSaQ"
      },
      "source": [
        "원소의 수를 유지하면서 텐서의 크기 변경, numpy의 reshape와 같은 역할"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0E0uqBC8XYMD"
      },
      "source": [
        "t = np.array([[[0, 1, 2],\n",
        "               [3, 4, 5]],\n",
        "              [[6, 7, 8],\n",
        "               [9, 10, 11]]])\n",
        "ft = torch.FloatTensor(t)"
      ],
      "execution_count": 30,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "r3Zi8EEfXrWv",
        "outputId": "1e065899-a441-462b-a8ab-cf6f9f36b0fe"
      },
      "source": [
        "# 3차원에서 2차원 텐서로 변경\n",
        "print(ft.view([-1, 3])) # ft라는 텐서를 (?, 3)의 크기로 변경\n",
        "print(ft.view([-1, 3]).shape)"
      ],
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([[ 0.,  1.,  2.],\n",
            "        [ 3.,  4.,  5.],\n",
            "        [ 6.,  7.,  8.],\n",
            "        [ 9., 10., 11.]])\n",
            "torch.Size([4, 3])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "a8DIZjcgXvWs",
        "outputId": "60f8ac38-edc8-4a43-8576-32fbb523b220"
      },
      "source": [
        "# 3차원 텐서의 크기 변경\n",
        "print(ft.view([-1, 1, 3]))\n",
        "print(ft.view([-1, 1, 3]).shape)"
      ],
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([[[ 0.,  1.,  2.]],\n",
            "\n",
            "        [[ 3.,  4.,  5.]],\n",
            "\n",
            "        [[ 6.,  7.,  8.]],\n",
            "\n",
            "        [[ 9., 10., 11.]]])\n",
            "torch.Size([4, 1, 3])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VGWfGw2-YHN_"
      },
      "source": [
        "> 연결(concatenate)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aoc8TVloYJgW"
      },
      "source": [
        "x = torch.FloatTensor([[1, 2], \n",
        "                       [3, 4]])\n",
        "y = torch.FloatTensor([[5, 6], \n",
        "                       [7, 8]])"
      ],
      "execution_count": 33,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QgzNcLTBYLi9",
        "outputId": "66b47473-f32f-4a71-9e92-d4d0df5f35bb"
      },
      "source": [
        "print(torch.cat([x, y], dim=0)) #dim=0이므로 첫번째 차원을 늘림"
      ],
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([[1., 2.],\n",
            "        [3., 4.],\n",
            "        [5., 6.],\n",
            "        [7., 8.]])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "K-_M_sByYSMS",
        "outputId": "ae38851c-6be8-410b-860a-fea5e1230714"
      },
      "source": [
        "print(torch.cat([x, y], dim=1)) "
      ],
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([[1., 2., 5., 6.],\n",
            "        [3., 4., 7., 8.]])\n"
          ]
        }
      ]
    }
  ]
}