01_tensor.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import torch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "metadata": {},
   "outputs": [],
   "source": [
    "# https://subinium.github.io/pytorch-Tensor-Variable/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src='img/tensor.png'/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating tensor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* fixed dtype constructor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([1., 2., 3., 4., 5.]) torch.float32\n"
     ]
    }
   ],
   "source": [
    "t = torch.FloatTensor([1,2,3,4,5]) # torch.Tensor is alias for torch.FloatTensor\n",
    "print(t, t.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* specifying dtype with torch.tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([1, 2, 3, 4, 5], dtype=torch.int32)\n"
     ]
    }
   ],
   "source": [
    "t = torch.tensor([1,2,3,4,5], dtype=torch.int32) # or could use torch.IntTensor\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* empty tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[-4.0221e+35,  4.5778e-41,  5.2935e+08],\n",
       "        [ 3.0904e-41,         nan,  0.0000e+00]])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.Tensor(2,3) # using fixed dtype constructor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[1308390000,      22054, 1308257152],\n",
       "        [     22054,          1,          0]], dtype=torch.int32)"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.empty((2,4), dtype=torch.int32) # specify dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* from numpy array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "float64\n",
      "tensor([[0.3743, 0.8407, 0.1824],\n",
      "        [0.4239, 0.2597, 0.8500]], dtype=torch.float64)\n",
      "tensor([[3.0000, 0.8407, 0.1824],\n",
      "        [0.4239, 0.2597, 0.8500]], dtype=torch.float64)\n",
      "tensor([[0.3743, 0.8407, 0.1824],\n",
      "        [0.4239, 0.2597, 0.8500]])\n",
      "tensor([[3.0000, 0.8407, 0.1824],\n",
      "        [0.4239, 0.2597, 0.8500]], dtype=torch.float64)\n"
     ]
    }
   ],
   "source": [
    "arr = np.random.rand(2,3)\n",
    "print(arr.dtype)\n",
    "\n",
    "# torch.tensor는 항상 copy를 함\n",
    "t1 = torch.tensor(arr) # copy of arr\n",
    "t2 = torch.from_numpy(arr) # share memory with arr\n",
    "\n",
    "# dtype이 다른 생성자를 쓸 경우 copy 함\n",
    "t3 = torch.FloatTensor(arr) # copy of arr\n",
    "t4 = torch.DoubleTensor(arr) # share memory with arr\n",
    "\n",
    "arr[0,0] = 3\n",
    "\n",
    "print(t1)\n",
    "print(t2)\n",
    "print(t3)\n",
    "print(t4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* ones / zeros"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[1., 1., 1., 1.],\n",
      "        [1., 1., 1., 1.],\n",
      "        [1., 1., 1., 1.]])\n"
     ]
    }
   ],
   "source": [
    "ones = torch.ones(3,4)\n",
    "print(ones)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[0., 0., 0., 0., 0.],\n",
      "        [0., 0., 0., 0., 0.]])\n"
     ]
    }
   ],
   "source": [
    "zeros = torch.zeros(2,5)\n",
    "print(zeroes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 217,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[1., 1., 1., 1., 1.],\n",
       "        [1., 1., 1., 1., 1.]])"
      ]
     },
     "execution_count": 217,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.ones_like(zeros) # shape 뿐만 아니라 device도 모방함"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0., 0., 0., 0.],\n",
       "        [0., 0., 0., 0.],\n",
       "        [0., 0., 0., 0.]])"
      ]
     },
     "execution_count": 216,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.zeros_like(ones)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Type casting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.float32\n"
     ]
    }
   ],
   "source": [
    "t = torch.Tensor([1,2,3])\n",
    "print(t.dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([1, 2, 3], dtype=torch.int32)"
      ]
     },
     "execution_count": 193,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.int() # t.float(), t.double(), ... => .to()에서 파생됨"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([1, 2, 3], dtype=torch.int32)"
      ]
     },
     "execution_count": 194,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.to(torch.int32) # 더 일반화된 버전, device도 바꿀 수 있음"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Attributes of tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = torch.Tensor([[1,2,3,4],[5,6,7,8]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "rank : 2\n",
      "shape : torch.Size([2, 4])\n",
      "number of elementss : 8\n"
     ]
    }
   ],
   "source": [
    "print('rank :', t.dim())\n",
    "print('shape :', t.shape)  # shape, same as t.size()\n",
    "print('number of elements :', t.numel())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Matrix multiplication"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* matrix multiplication\n",
    "  * tensor.matmul\n",
    "  * can be simplified to @"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([-1,  2,  0]) tensor([ 2, -1, -2])\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "tensor(-4)"
      ]
     },
     "execution_count": 160,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# vector x vector : 내적\n",
    "tensor1 = torch.randint(-3, 3, (3,))\n",
    "tensor2 = torch.randint(-3, 3, (3,))\n",
    "print(tensor1, tensor2)\n",
    "tensor1 @ tensor2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([0, 1, 1])\n",
      "tensor([[ 1,  1],\n",
      "        [ 1, -1],\n",
      "        [-3,  2]])\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "tensor([-2,  1])"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# vector x matrix\n",
    "tensor1 = torch.randint(-3, 3, (3,))\n",
    "tensor2 = torch.randint(-3, 3, (3,2))\n",
    "print(tensor1)\n",
    "print(tensor2)\n",
    "torch.matmul(tensor1, tensor2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ 1, -3, -2],\n",
      "        [ 0,  2, -2]]) tensor([-3,  1,  2])\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "tensor([-10,  -2])"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# matrix x vector\n",
    "tensor1 = torch.randint(-3, 3, (2,3))\n",
    "tensor2 = torch.randint(-3, 3, (3,))\n",
    "print(tensor1, tensor2)\n",
    "torch.matmul(tensor1, tensor2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[-1,  1,  0],\n",
      "        [ 2,  0, -1]])\n",
      "tensor([[-2,  0],\n",
      "        [ 0,  0],\n",
      "        [-2, -1]])\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "tensor([[ 2,  0],\n",
       "        [-2,  1]])"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# matrix x matrix\n",
    "tensor1 = torch.randint(-3, 3, (2,3))\n",
    "tensor2 = torch.randint(-3, 3, (3,2))\n",
    "print(tensor1)\n",
    "print(tensor2)\n",
    "torch.matmul(tensor1, tensor2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[[ 0, -1, -3,  1],\n",
      "         [-1, -1,  0,  0]],\n",
      "\n",
      "        [[-1,  2, -2, -3],\n",
      "         [ 0,  2, -2, -2]],\n",
      "\n",
      "        [[ 1, -3,  0,  0],\n",
      "         [ 0,  2,  1,  2]]])\n",
      "tensor([-3,  0,  0, -3])\n",
      "tensor([[-3,  3],\n",
      "        [12,  6],\n",
      "        [-3, -6]])\n",
      "torch.Size([3, 2, 4]) torch.Size([4]) torch.Size([3, 2])\n"
     ]
    }
   ],
   "source": [
    "# batched matrix x broadcasted vector\n",
    "tensor1 = torch.randint(-3, 3, (3, 2, 4))\n",
    "tensor2 = torch.randint(-3, 3, (4,))\n",
    "print(tensor1)\n",
    "print(tensor2)\n",
    "out = torch.matmul(tensor1, tensor2)\n",
    "print(out)\n",
    "print(tensor1.shape, tensor2.shape, out.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([10, 7, 3, 4]) torch.Size([10, 7, 4, 2]) torch.Size([10, 7, 3, 2])\n"
     ]
    }
   ],
   "source": [
    "# batched matrix x batched matrix\n",
    "tensor1 = torch.randint(-3, 3, (10, 7, 3, 4))\n",
    "tensor2 = torch.randint(-3, 3, (10, 7, 4, 2))\n",
    "out = torch.matmul(tensor1, tensor2)\n",
    "print(tensor1.shape, tensor2.shape, out.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([10, 17, 8, 3, 4]) torch.Size([8, 4, 5]) torch.Size([10, 17, 8, 3, 5])\n"
     ]
    }
   ],
   "source": [
    "# batched matrix x broadcasted matrix\n",
    "tensor1 = torch.randn(10, 17, 8, 3, 4)\n",
    "tensor2 = torch.randn(8, 4, 5)\n",
    "out = torch.matmul(tensor1, tensor2)\n",
    "print(tensor1.shape, tensor2.shape, out.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[0.6058, 0.1385, 0.7620],\n",
      "        [0.5414, 0.6441, 0.0289]])\n",
      "tensor(2.7207)\n",
      "tensor([1.1473, 0.7825, 0.7909])\n"
     ]
    }
   ],
   "source": [
    "tensor1 = torch.rand(2,3)\n",
    "print(tensor1)\n",
    "print(tensor1.sum())\n",
    "print(tensor1.sum(dim=0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* mean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[0.0698, 0.1095, 0.9531],\n",
      "        [0.1867, 0.8605, 0.9056]])\n",
      "tensor(0.5142)\n",
      "tensor([0.1283, 0.4850, 0.9294])\n"
     ]
    }
   ],
   "source": [
    "tensor1 = torch.rand(2,3)\n",
    "print(tensor1)\n",
    "print(tensor1.mean())\n",
    "print(tensor1.mean(dim=0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* max"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[0.4007, 0.8787, 0.8945],\n",
      "        [0.1014, 0.1244, 0.4214]])\n",
      "tensor(0.8945)\n",
      "torch.return_types.max(\n",
      "values=tensor([0.4007, 0.8787, 0.8945]),\n",
      "indices=tensor([0, 0, 0]))\n"
     ]
    }
   ],
   "source": [
    "tensor1 = torch.rand(2,3)\n",
    "print(tensor1)\n",
    "print(tensor1.max())\n",
    "print(tensor1.max(dim=0)) # also returns argmax"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* argmax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[0.0418, 0.3779, 0.4596],\n",
      "        [0.7039, 0.3551, 0.4305]])\n",
      "tensor(3)\n",
      "tensor([1, 0, 0])\n"
     ]
    }
   ],
   "source": [
    "tensor1 = torch.rand(2,3)\n",
    "print(tensor1)\n",
    "print(tensor1.argmax())\n",
    "print(tensor1.argmax(dim=0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## View operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* view / reshape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([0.9416, 0.9754, 0.4000, 0.8737, 0.0241, 0.7994, 0.8812, 0.1809, 0.4543,\n",
       "        0.6158, 0.9539, 0.9243])"
      ]
     },
     "execution_count": 175,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t = torch.rand(12)\n",
    "t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[[[0.9416],\n",
       "          [0.9754],\n",
       "          [0.4000],\n",
       "          [0.8737]]],\n",
       "\n",
       "\n",
       "        [[[0.0241],\n",
       "          [0.7994],\n",
       "          [0.8812],\n",
       "          [0.1809]]],\n",
       "\n",
       "\n",
       "        [[[0.4543],\n",
       "          [0.6158],\n",
       "          [0.9539],\n",
       "          [0.9243]]]])"
      ]
     },
     "execution_count": 180,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t = t.view(3, 1, 4, 1) # t.reshape 도 가능하지만 reshape은 view와 다르게 항상 memory share를 보장하지 않음\n",
    "t"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* squeeze / unsqueeze"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([3, 1, 4, 1])\n",
      "torch.Size([3, 4])\n",
      "torch.Size([3, 4, 1])\n",
      "torch.Size([1, 3, 1, 4, 1])\n"
     ]
    }
   ],
   "source": [
    "print(t.shape)\n",
    "print(t.squeeze().shape)\n",
    "print(t.squeeze(1).shape)\n",
    "print(t.unsqueeze(0).shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> transpose, permute, scatter, gather"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Merging operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = torch.FloatTensor([[1, 2, 3], [3, 4, 5], [6, 7, 8]])\n",
    "y = torch.FloatTensor([[5, 6, 7], [7, 8, 9], [9, 10, 11]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* concatenate : reserve dimension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ 1.,  2.,  3.],\n",
      "        [ 3.,  4.,  5.],\n",
      "        [ 6.,  7.,  8.],\n",
      "        [ 5.,  6.,  7.],\n",
      "        [ 7.,  8.,  9.],\n",
      "        [ 9., 10., 11.]]) torch.Size([6, 3])\n",
      "tensor([[ 1.,  2.,  3.,  5.,  6.,  7.],\n",
      "        [ 3.,  4.,  5.,  7.,  8.,  9.],\n",
      "        [ 6.,  7.,  8.,  9., 10., 11.]]) torch.Size([3, 6])\n"
     ]
    }
   ],
   "source": [
    "merged = torch.cat([x, y])\n",
    "print(merged, merged.shape)\n",
    "\n",
    "merged = torch.cat([x, y], dim = 1)\n",
    "print(merged, merged.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* stack : add dimension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[[ 1.,  2.,  3.],\n",
      "         [ 3.,  4.,  5.],\n",
      "         [ 6.,  7.,  8.]],\n",
      "\n",
      "        [[ 5.,  6.,  7.],\n",
      "         [ 7.,  8.,  9.],\n",
      "         [ 9., 10., 11.]]]) torch.Size([2, 3, 3])\n"
     ]
    }
   ],
   "source": [
    "merged = torch.stack([x,y])\n",
    "print(merged, merged.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[[ 1.,  2.,  3.],\n",
      "         [ 5.,  6.,  7.]],\n",
      "\n",
      "        [[ 3.,  4.,  5.],\n",
      "         [ 7.,  8.,  9.]],\n",
      "\n",
      "        [[ 6.,  7.,  8.],\n",
      "         [ 9., 10., 11.]]]) torch.Size([3, 2, 3])\n"
     ]
    }
   ],
   "source": [
    "merged = torch.stack([x,y], dim=1)\n",
    "print(merged, merged.shape)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "pytorch",
   "language": "python",
   "name": "pytorch"
  },
  "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}