02-PyTorch/01-텐서를-생성하는-다양한방법.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## torch import"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.10.1+cu111\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import numpy as np\n",
    "\n",
    "# version 체크\n",
    "print(torch.__version__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 기본 텐서 생성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4]\n"
     ]
    }
   ],
   "source": [
    "# 샘플 numpy array 생성\n",
    "arr = np.arange(0, 5)\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `torch.from_numpy()`\n",
    "\n",
    "- numpy array 로부터 생성. **sharing** 하므로 numpy array의 요소가 변경되면 tensor로 같이 변경됩니다"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([0, 1, 2, 3, 4])\n",
      "torch.int64\n",
      "torch.LongTensor\n",
      "<class 'torch.Tensor'>\n"
     ]
    }
   ],
   "source": [
    "t1 = torch.from_numpy(arr)\n",
    "print(t1) # 출력\n",
    "print(t1.dtype)  # dtype은 데이터 타입\n",
    "print(t1.type()) # type()은 텐서의 타입\n",
    "print(type(t1))  # t1 변수 자체의 타입"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `torch.as_tensor()`\n",
    "\n",
    "- numpy array 로부터 생성. **sharing** 하므로 numpy array의 요소가 변경되면 tensor로 같이 변경됩니다"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([0, 1, 2, 3, 4])\n",
      "torch.int64\n",
      "torch.LongTensor\n",
      "<class 'torch.Tensor'>\n"
     ]
    }
   ],
   "source": [
    "t2 = torch.as_tensor(arr)\n",
    "print(t2) # 출력\n",
    "print(t2.dtype)  # dtype은 데이터 타입\n",
    "print(t2.type()) # type()은 텐서의 타입\n",
    "print(type(t2))  # t2 변수 자체의 타입"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `torch.tensor()` \n",
    "\n",
    "- numpy array 로부터 생성. **copying** 하므로 numpy array의 요소가 변경에 영향을 받지 않습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([0, 1, 2, 3, 4])\n",
      "torch.int64\n",
      "torch.LongTensor\n",
      "<class 'torch.Tensor'>\n"
     ]
    }
   ],
   "source": [
    "t3 = torch.tensor(arr)\n",
    "print(t3) # 출력\n",
    "print(t3.dtype)  # dtype은 데이터 타입\n",
    "print(t3.type()) # type()은 텐서의 타입\n",
    "print(type(t3))  # t3 변수 자체의 타입"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Zeros, Ones"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `torch.zeros()`\n",
    "\n",
    "- 0으로 채워진 tensor를 생성합니다.\n",
    "- dtype을 직접 지정하는 것이 바람직합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[0, 0, 0, 0, 0],\n",
      "        [0, 0, 0, 0, 0],\n",
      "        [0, 0, 0, 0, 0]], dtype=torch.int32)\n",
      "torch.int32\n",
      "torch.IntTensor\n"
     ]
    }
   ],
   "source": [
    "zeros = torch.zeros(3, 5, dtype=torch.int32)\n",
    "print(zeros)\n",
    "print(zeros.dtype)\n",
    "print(zeros.type())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `torch.ones()`\n",
    "\n",
    "- 1로 채워진 tensor를 생성합니다.\n",
    "- 역시 dtype을 직접 지정하는 것이 바람직합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[0, 0, 0],\n",
      "        [0, 0, 0]])\n",
      "torch.int64\n",
      "torch.LongTensor\n"
     ]
    }
   ],
   "source": [
    "ones = torch.zeros(2, 3, dtype=torch.int64)\n",
    "print(ones)\n",
    "print(ones.dtype)\n",
    "print(ones.type())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tensors from ranges\n",
    "<a href='https://pytorch.org/docs/stable/torch.html#torch.arange'><strong><tt>torch.arange(start,end,step)</tt></strong></a><br>\n",
    "<a href='https://pytorch.org/docs/stable/torch.html#torch.linspace'><strong><tt>torch.linspace(start,end,steps)</tt></strong></a><br>\n",
    "Note that with <tt>.arange()</tt>, <tt>end</tt> is exclusive, while with <tt>linspace()</tt>, <tt>end</tt> is inclusive."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 범위로 생성"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `torch.arange(start, end, step)`\n",
    "\n",
    "- 지정된 범위로 tensor를 생성합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([0, 1, 2, 3, 4])\n",
      "tensor([2, 3, 4, 5])\n",
      "tensor([1, 3, 5, 7, 9])\n"
     ]
    }
   ],
   "source": [
    "# end만 지정\n",
    "a = torch.arange(5)\n",
    "print(a)\n",
    "# start, end 지정\n",
    "a = torch.arange(2, 6)\n",
    "print(a)\n",
    "# start, end, step 모두 지정\n",
    "a = torch.arange(1, 10, 2)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### torch.linspace(start, end, steps)\n",
    "\n",
    "- start부터 end까지 동일 간격으로 생성합니다. steps 지정시 steps 갯수만큼 생성합니다. (미지정시 100개 생성)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([ 2.0000,  2.0808,  2.1616,  2.2424,  2.3232,  2.4040,  2.4848,  2.5657,\n",
      "         2.6465,  2.7273,  2.8081,  2.8889,  2.9697,  3.0505,  3.1313,  3.2121,\n",
      "         3.2929,  3.3737,  3.4545,  3.5354,  3.6162,  3.6970,  3.7778,  3.8586,\n",
      "         3.9394,  4.0202,  4.1010,  4.1818,  4.2626,  4.3434,  4.4242,  4.5051,\n",
      "         4.5859,  4.6667,  4.7475,  4.8283,  4.9091,  4.9899,  5.0707,  5.1515,\n",
      "         5.2323,  5.3131,  5.3939,  5.4747,  5.5556,  5.6364,  5.7172,  5.7980,\n",
      "         5.8788,  5.9596,  6.0404,  6.1212,  6.2020,  6.2828,  6.3636,  6.4444,\n",
      "         6.5253,  6.6061,  6.6869,  6.7677,  6.8485,  6.9293,  7.0101,  7.0909,\n",
      "         7.1717,  7.2525,  7.3333,  7.4141,  7.4949,  7.5758,  7.6566,  7.7374,\n",
      "         7.8182,  7.8990,  7.9798,  8.0606,  8.1414,  8.2222,  8.3030,  8.3838,\n",
      "         8.4646,  8.5455,  8.6263,  8.7071,  8.7879,  8.8687,  8.9495,  9.0303,\n",
      "         9.1111,  9.1919,  9.2727,  9.3535,  9.4343,  9.5152,  9.5960,  9.6768,\n",
      "         9.7576,  9.8384,  9.9192, 10.0000])\n",
      "100\n",
      "============================================================\n",
      "tensor([ 2.,  4.,  6.,  8., 10.])\n"
     ]
    }
   ],
   "source": [
    "# start, stop 지정 ()\n",
    "b = torch.linspace(2, 10)\n",
    "print(b)\n",
    "print(b.size(0))\n",
    "print('==='*20)\n",
    "# start, stop, step 모두 지정\n",
    "b = torch.linspace(2, 10, 5)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## tensor의 타입 변경: type()\n",
    "\n",
    "- tensor의 dtype을 변경하기 위해서는 type() 함수를 사용합니다. type()함수의 인자로 변경할 tensor의 타입을 지정합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=torch.int32)\n",
      "torch.IntTensor\n",
      "==============================\n",
      "tensor([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])\n",
      "torch.LongTensor\n"
     ]
    }
   ],
   "source": [
    "aa = torch.arange(10, dtype=torch.int32)\n",
    "print(aa)\n",
    "print(aa.type())\n",
    "\n",
    "print('==='*10)\n",
    "# tensor의 타입 변경\n",
    "bb = aa.type(torch.int64)\n",
    "print(bb)\n",
    "print(bb.type())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 랜덤 tensor 생성\n",
    "\n",
    "- `torch.rand()`: [0, 1) 분포 안에서 랜덤한 tensor를 생성합니다.\n",
    "- `torch.randn()`: **standard normal** 분포 안에서 랜덤한 tensor를 생성합니다.\n",
    "- `torch.randint()`: 정수로 채워진 랜덤한 tensor를 생성합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[0.3794, 0.0123, 0.5955],\n",
      "        [0.9275, 0.2572, 0.5693]])\n"
     ]
    }
   ],
   "source": [
    "# random 생성 범위: 0 ~ 1 \n",
    "rd1 = torch.rand(2, 3)\n",
    "print(rd1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ 0.9815,  0.4774,  2.2860],\n",
      "        [-1.8257, -0.0598, -1.5680]])\n"
     ]
    }
   ],
   "source": [
    "# random 생성 범위: standard normal\n",
    "rd2 = torch.randn(2, 3)\n",
    "print(rd2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[9, 8, 7],\n",
      "        [3, 4, 1]])\n"
     ]
    }
   ],
   "source": [
    "# randint 생성시 low, high, size를 지정한 경우\n",
    "rd3 = torch.randint(low=1, high=10, size=(2, 3))\n",
    "print(rd3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`torch.manual_seed()`: 난수 생성시 시드의 고정"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[99, 19, 57],\n",
      "        [70, 53, 70]])\n"
     ]
    }
   ],
   "source": [
    "# manual_seed를 고정시 고정한 cell의 난수 생성은 매번 동일한 값을 생성\n",
    "torch.manual_seed(0)\n",
    "rd4 = torch.randint(low=1, high=100, size=(2, 3))\n",
    "print(rd4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## like로 tensor 생성\n",
    "\n",
    "- 텐서 생성 함수에서 `_like()`가 뒤에 붙는 함수를 종종 볼 수 있습니다.\n",
    "- `_like()`가 붙은 이름의 함수는 `_like()` 안에 넣어주는 tensor의 shape와 동일한 tensor를 생성합니다.\n",
    "\n",
    "**_like() 함수 목록**\n",
    "- `torch.rand_like()`\n",
    "- `torch.randn_like()`\n",
    "- `torch.randint_like()`\n",
    "- `torch.ones_like()`\n",
    "- `torch.zeros_like()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ 1.,  3.,  5.],\n",
      "        [ 7.,  9., 11.]])\n",
      "torch.FloatTensor\n"
     ]
    }
   ],
   "source": [
    "x = torch.tensor([[1, 3, 5], \n",
    "                  [7, 9, 11]], dtype=torch.float32)\n",
    "print(x)\n",
    "print(x.type())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[0.6833, 0.7529, 0.8579],\n",
      "        [0.6870, 0.0051, 0.1757]])\n",
      "torch.FloatTensor\n"
     ]
    }
   ],
   "source": [
    "# [0, 1)\n",
    "like1 = torch.rand_like(x)\n",
    "print(like1)\n",
    "print(like1.type())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[-0.5382,  0.5880,  1.6059],\n",
      "        [ 0.4279, -0.6776,  1.0422]])\n",
      "torch.FloatTensor\n"
     ]
    }
   ],
   "source": [
    "# standard normal\n",
    "like2 = torch.randn_like(x)\n",
    "print(like2)\n",
    "print(like2.type())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[70., 62., 10.],\n",
      "        [69., 22.,  5.]])\n",
      "torch.FloatTensor\n"
     ]
    }
   ],
   "source": [
    "# int range\n",
    "like3 = torch.randint_like(x, low=1, high=100)\n",
    "print(like3)\n",
    "print(like3.type())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[0., 0., 0.],\n",
      "        [0., 0., 0.]])\n",
      "torch.FloatTensor\n"
     ]
    }
   ],
   "source": [
    "# zeros\n",
    "like4 = torch.zeros_like(x)\n",
    "print(like4)\n",
    "print(like4.type())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[1., 1., 1.],\n",
      "        [1., 1., 1.]])\n",
      "torch.FloatTensor\n"
     ]
    }
   ],
   "source": [
    "# ones\n",
    "like5 = torch.ones_like(x)\n",
    "print(like5)\n",
    "print(like5.type())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## tensor의 shape 확인 및 변경"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ 1.,  3.,  5.],\n",
      "        [ 7.,  9., 11.]])\n"
     ]
    }
   ],
   "source": [
    "x = torch.tensor([[1, 3, 5], \n",
    "                  [7, 9, 11]], dtype=torch.float32)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### shape 확인"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([2, 3])\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "print(x.shape)\n",
    "print(x.shape[0])\n",
    "print(x.shape[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([2, 3])\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "print(x.size())\n",
    "print(x.size(0))\n",
    "print(x.size(1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### shape 변경"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`view()`와 `reshape()` 모두 사용가능합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ 1.,  3.,  5.],\n",
      "        [ 7.,  9., 11.]])\n",
      "torch.Size([2, 3])\n"
     ]
    }
   ],
   "source": [
    "x = torch.tensor([[1, 3, 5], \n",
    "                  [7, 9, 11]], dtype=torch.float32)\n",
    "print(x)\n",
    "print(x.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ 1.,  3.,  5.],\n",
      "        [ 7.,  9., 11.]])\n",
      "tensor([[ 1.,  3.],\n",
      "        [ 5.,  7.],\n",
      "        [ 9., 11.]])\n"
     ]
    }
   ],
   "source": [
    "print(x)\n",
    "# view()로 shape 변경\n",
    "print(x.view(3, 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[ 1.],\n",
       "        [ 3.],\n",
       "        [ 5.],\n",
       "        [ 7.],\n",
       "        [ 9.],\n",
       "        [11.]])"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# view\n",
    "x.view(-1, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[ 1.],\n",
       "        [ 3.],\n",
       "        [ 5.],\n",
       "        [ 7.],\n",
       "        [ 9.],\n",
       "        [11.]])"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# reshape\n",
    "x.reshape(-1, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[ 1.,  3.],\n",
       "        [ 5.,  7.],\n",
       "        [ 9., 11.]])"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# view\n",
    "x.view(3, -1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[ 1.,  3.],\n",
       "        [ 5.,  7.],\n",
       "        [ 9., 11.]])"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# reshape\n",
    "x.reshape(3, -1)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}