Basic/01_basic.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.2.0\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import torch\n",
    "torch.manual_seed(1)\n",
    "print(torch.__version__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# base Tenseor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0., 0.],\n",
       "        [0., 0.]])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = torch.Tensor(2,2)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('torch.FloatTensor', torch.Size([2, 2]), 4)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.type(), x.size(), x.numel()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[[[1.0504e-05],\n",
       "          [4.1654e-11]],\n",
       "\n",
       "         [[1.0621e-05],\n",
       "          [2.9574e-18]],\n",
       "\n",
       "         [[6.7333e+22],\n",
       "          [1.7591e+22]]],\n",
       "\n",
       "\n",
       "        [[[1.7184e+25],\n",
       "          [4.3222e+27]],\n",
       "\n",
       "         [[6.1972e-04],\n",
       "          [7.2443e+22]],\n",
       "\n",
       "         [[1.7728e+28],\n",
       "          [7.0367e+22]]],\n",
       "\n",
       "\n",
       "        [[[2.9926e+21],\n",
       "          [1.1050e-05]],\n",
       "\n",
       "         [[1.0481e-11],\n",
       "          [6.7126e-07]],\n",
       "\n",
       "         [[4.3679e-05],\n",
       "          [1.0978e-05]]],\n",
       "\n",
       "\n",
       "        [[[1.6535e-04],\n",
       "          [2.0430e+20]],\n",
       "\n",
       "         [[2.0567e+20],\n",
       "          [2.4287e-18]],\n",
       "\n",
       "         [[7.7052e+31],\n",
       "          [1.9447e+31]]]])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x2 = torch.Tensor(4,3,2,1)\n",
    "x2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(torch.Size([4, 3, 2, 1]), 'torch.FloatTensor', 24)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x2.size(), x2.type(), x2.numel()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "# Other methods make to Tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([[0., 0., 0., 0.],\n",
       "         [0., 0., 0., 0.],\n",
       "         [0., 0., 0., 0.],\n",
       "         [0., 0., 0., 0.]]), tensor([[1., 1., 1., 1.],\n",
       "         [1., 1., 1., 1.],\n",
       "         [1., 1., 1., 1.],\n",
       "         [1., 1., 1., 1.]]), tensor([[1., 0., 0., 0.],\n",
       "         [0., 1., 0., 0.],\n",
       "         [0., 0., 1., 0.],\n",
       "         [0., 0., 0., 1.]]), tensor([[0.7576, 0.2793, 0.4031, 0.7347],\n",
       "         [0.0293, 0.7999, 0.3971, 0.7544],\n",
       "         [0.5695, 0.4388, 0.6387, 0.5247],\n",
       "         [0.6826, 0.3051, 0.4635, 0.4550]]), tensor([[-0.6970, -1.1608,  0.6995,  0.1991],\n",
       "         [ 0.8657,  0.2444, -0.6629,  0.8073],\n",
       "         [ 1.1017, -0.1759, -2.2456, -1.4465],\n",
       "         [ 0.0612, -0.6177, -0.7981, -0.1316]]))"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.zeros(4,4), torch.ones(4,4), torch.eye(4,4),torch.rand(4,4), torch.randn(4,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([0.0000, 0.3000, 0.6000, 0.9000, 1.2000, 1.5000, 1.8000, 2.1000, 2.4000,\n",
       "        2.7000])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x3 = torch.arange(0, 3, step=0.3)\n",
    "x3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([0.0000, 0.3000, 0.6000, 0.9000, 1.2000, 1.5000, 1.8000, 2.1000, 2.4000,\n",
       "        2.7000])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[6., 2.],\n",
       "        [3., 4.],\n",
       "        [5., 6.]])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.Tensor([[6,2],[3,4],[5,6]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[ 5,  6],\n",
       "        [10, 11]], dtype=torch.int32)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numpy_test = np.array([[5,6],[10,11]])\n",
    "torch.from_numpy(numpy_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "# Use to array function of Python make Tensor "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[1., 2., 3.],\n",
       "        [4., 5., 6.],\n",
       "        [7., 8., 9.]])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x4 = torch.Tensor([[1,2,3],[4,5,6],[7,8,9]])\n",
    "x4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[1., 2., 3.],\n",
       "        [4., 5., 6.]])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x4[0:2,:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([4., 5., 6.])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x4[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([1., 2., 3.])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x4[0,:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[62., 72., 80.],\n",
       "        [ 4.,  5.,  6.],\n",
       "        [ 7.,  8.,  9.]])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x4[0:1,:] = torch.Tensor([62,72,80])\n",
    "x4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[ 62.,  72.,  80.],\n",
       "        [200.,  78.,  89.],\n",
       "        [  7.,   8.,   9.]])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x4[1] = torch.Tensor([200,78, 89])\n",
    "x4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([[62., 72., 80.]]),\n",
       " tensor([[200.,  78.,  89.]]),\n",
       " tensor([[7., 8., 9.]]))"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x5 = torch.split(x4, split_size_or_sections=1,dim=0)\n",
    "x5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[ 62.,  72.,  80., 200.,  78.,  89.,   7.,   8.,   9.]])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.cat(x5, dim=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[[ 62.,  72.,  80.],\n",
       "         [200.,  78.,  89.],\n",
       "         [  7.,   8.,   9.]]])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.stack(x5, dim=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "..\\aten\\src\\ATen\\native\\LegacyDefinitions.cpp:48: UserWarning: masked_select received a mask with dtype torch.uint8, this behavior is now deprecated,please use a mask with dtype torch.bool instead.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(tensor([[-0.4791,  1.3790,  2.5286],\n",
       "         [ 0.4107, -0.9880, -0.9081],\n",
       "         [ 0.5423,  0.1103, -2.2590]]), tensor([[1, 0, 0],\n",
       "         [1, 1, 1],\n",
       "         [0, 1, 0]], dtype=torch.uint8), tensor([-0.4791,  0.4107, -0.9880, -0.9081,  0.1103]))"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x6 = torch.randn(3,3)\n",
    "\n",
    "mask  = torch.ByteTensor([[1,0,0],[1,1,1],[0,1,0]])\n",
    "\n",
    "out = torch.masked_select(x6, mask)\n",
    "\n",
    "x6, mask, out"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "# Reshaping on dimension of Tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[[0.],\n",
       "         [0.]],\n",
       "\n",
       "        [[0.],\n",
       "         [0.]]])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x7 = torch.zeros(2,2,1)\n",
    "x7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0., 0.],\n",
       "        [0., 0.]])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x7.view(2,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([0., 0., 0., 0.])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x7.view(-1) # -1 = Automatic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0., 0.],\n",
       "        [0., 0.]])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x7.view(-1,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([0., 0., 0., 0.])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x7.view(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([[[0.],\n",
       "          [0.]],\n",
       " \n",
       "         [[0.],\n",
       "          [0.]]]), tensor([[0., 0.],\n",
       "         [0., 0.]]))"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x8 = x7.squeeze()\n",
    "x7, x8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[[0., 0.],\n",
       "         [0., 0.]]])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x8.unsqueeze(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "# Calculate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([[10., 20., 30.],\n",
       "         [40., 50., 60.]]), tensor([[1., 2., 3.],\n",
       "         [4., 5., 6.]]))"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x9 = torch.FloatTensor([[10,20,30],[40,50,60]])\n",
    "x10 = torch.FloatTensor([[1,2,3],[4,5,6]])\n",
    "x9, x10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([[11., 22., 33.],\n",
       "         [44., 55., 66.]]), tensor([[11., 22., 33.],\n",
       "         [44., 55., 66.]]), tensor([[11., 22., 33.],\n",
       "         [44., 55., 66.]]))"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x9  + x10, x9.add(x10), torch.add(x9, x10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([[ -9., -18., -27.],\n",
       "         [-36., -45., -54.]]), tensor([[ 9., 18., 27.],\n",
       "         [36., 45., 54.]]))"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x10.sub(x9), x9.sub(x10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([16., 17., 18.])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x10[1] + 12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([[ 10.,  40.,  90.],\n",
       "         [160., 250., 360.]]), tensor([[ 10.,  40.,  90.],\n",
       "         [160., 250., 360.]]), tensor([[ 10.,  40.,  90.],\n",
       "         [160., 250., 360.]]))"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x9 * x10, x10.mul(x9), torch.mul(x10,x9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[10., 20., 30.],\n",
       "        [40., 50., 60.]])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x10 * 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "# Other Calculate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([[ 100.,  400.,  900.],\n",
       "         [1600., 2500., 3600.]]), tensor([[ 100.,  400.,  900.],\n",
       "         [1600., 2500., 3600.]]), tensor([[ 100.,  400.,  900.],\n",
       "         [1600., 2500., 3600.]]))"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x9.pow(2), torch.pow(x9,2), x9 ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[3.1623, 4.4721, 5.4772],\n",
       "        [6.3246, 7.0711, 7.7460]])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x9.sqrt()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([[0.0000, 0.6931, 1.0986],\n",
       "         [1.3863, 1.6094, 1.7918]]), tensor([[0.0000, 0.6931, 1.0986],\n",
       "         [1.3863, 1.6094, 1.7918]]))"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x10.log(), torch.log(x10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([[1., 2., 0.],\n",
       "         [1., 2., 0.]]), tensor([[ 3.3333,  6.6667, 10.0000],\n",
       "         [13.3333, 16.6667, 20.0000]]))"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x9 % 3, x9 / 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor(210.), tensor(60.))"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x9.sum(), x9.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor(1.), torch.return_types.min(\n",
       " values=tensor([1., 2., 3.]),\n",
       " indices=tensor([0, 0, 0])), torch.return_types.min(\n",
       " values=tensor([1., 4.]),\n",
       " indices=tensor([0, 0])))"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x10.min(), x10.min(0), x10.min(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.return_types.max(\n",
       "values=tensor([3., 6.]),\n",
       "indices=tensor([2, 2]))"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x10.max(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([[10., 20., 30.],\n",
       "         [40., 50., 60.]]), tensor([[10., 20., 30.],\n",
       "         [40., 50., 60.]]))"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x9.abs(), x9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([[ 10.,  20.,  30.],\n",
       "         [ -3.,   3., -10.]]), tensor([[10., 20., 30.],\n",
       "         [ 3.,  3., 10.]]))"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x9[1] = torch.Tensor([-3,3,-10])\n",
    "x9, x9.abs()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([3., 6.]), tensor([2, 2]))"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "value, index = x10.max(dim = 1)\n",
    "value, index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(6.)"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x10.max()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "# Matrix Calculate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([[ 0.6067, -0.1383,  0.8310, -0.2477, -0.8029],\n",
       "         [ 0.2366,  0.2857,  0.6898, -0.6331,  0.8795],\n",
       "         [-0.6842,  0.4533,  0.2912, -0.8317, -0.5525]]),\n",
       " tensor([[ 1.3851, -0.8138, -0.9276,  1.1120,  0.6155],\n",
       "         [ 0.1938, -2.5832,  0.8539, -2.1021,  0.3476],\n",
       "         [ 0.0930,  0.6147,  0.7124, -1.7765,  0.3539],\n",
       "         [ 1.1996, -0.3030, -0.6200, -0.2281, -0.7893],\n",
       "         [-1.6111, -1.8716,  0.5431,  0.6607,  2.2952]]),\n",
       " tensor([[ 0.6355, -1.0901, -0.2380],\n",
       "         [ 0.6905,  0.4646, -0.7559],\n",
       "         [-2.0501,  0.6842, -0.8003],\n",
       "         [-0.3738,  1.4904, -1.2968],\n",
       "         [-0.3243,  0.3105, -0.3423]]))"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x11 = torch.randn(3,5)\n",
    "x12 = torch.randn(5,5)\n",
    "x13 = torch.randn(5,3)\n",
    "x11, x12, x13"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.33094226"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1.6200 * 1.1375  + 0.3436 * -0.9347 + -0.9112 * 1.3267 + -0.9952 *  -0.0336 + 0.7455 * 1.3210"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([[ 1.8873,  1.9522, -0.3714, -0.9849, -1.0280],\n",
       "         [-1.7291, -1.9607,  1.3861, -0.8375,  3.0073],\n",
       "         [-0.9403,  0.8509,  1.4448, -2.4062, -0.7722]]),\n",
       " tensor([[ 1.8873,  1.9522, -0.3714, -0.9849, -1.0280],\n",
       "         [-1.7291, -1.9607,  1.3861, -0.8375,  3.0073],\n",
       "         [-0.9403,  0.8509,  1.4448, -2.4062, -0.7722]]))"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.mm(x11,x12), x11.mm(x12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[ 4.0103e+00, -3.1916e+00,  1.3142e-03],\n",
       "        [-5.9565e+00,  1.6081e+00,  8.4113e-01],\n",
       "        [-1.8220e+00, -1.4170e+00,  1.8090e+00]])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x11.mm(x12).mm(x13)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[ 1.6771, -1.4659,  1.1313,  1.0260, -6.0277],\n",
       "        [-3.8089,  1.6645, -3.5958, -0.2421,  5.7323],\n",
       "        [-2.6783,  0.6672, -1.9648, -0.1562, -0.7828]])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x11.mm(x12).mm(x13).mm(x11)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([[ 0.6976,  1.4117,  2.1331, -0.1602],\n",
       "         [ 0.3615,  0.3725, -0.3054, -0.6147],\n",
       "         [-0.9315, -1.8460,  0.5781, -0.9483]]),\n",
       " tensor([ 0.0943,  0.6352, -0.6054, -0.2838]))"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x14 = torch.randn(3, 4)\n",
    "v = torch.randn(4)\n",
    "\n",
    "x14, v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-0.6250781"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " -0.4594 * 0.6623 + -1.1798 * 0.2916 +0.3812 * 0.0409+ -0.0064 *  -1.1908"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([-0.2833,  0.6300, -1.3412]), tensor([-0.2833,  0.6300, -1.3412]))"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.mv(x14,v), x14.mv(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([10, 3, 5])"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x15 = torch.randn(10,3,4)\n",
    "x16 = torch.randn(10,4,5)\n",
    "\n",
    "torch.bmm(x15, x16).size()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[[ 6.9434e-01,  6.0964e+00,  1.7202e+00, -3.8169e+00, -2.9654e+00],\n",
       "         [ 1.8189e+00, -1.8705e+00,  6.2631e-01, -9.5523e-01, -1.1729e+00],\n",
       "         [-2.5354e-01,  3.2282e+00,  4.7611e-01, -1.6111e+00, -5.8421e-01]],\n",
       "\n",
       "        [[ 2.3530e+00, -2.3066e+00, -4.9446e-01,  1.3988e+00,  2.5245e-01],\n",
       "         [ 1.9755e+00, -5.1293e-01,  3.7283e+00, -3.7956e-01, -2.2084e+00],\n",
       "         [-3.9758e+00,  4.6995e+00,  3.3093e+00, -2.5224e+00,  4.1832e-02]],\n",
       "\n",
       "        [[ 1.7741e+00, -1.5162e+00,  1.4017e+00, -2.0276e+00,  3.3163e-01],\n",
       "         [-6.6708e-01,  5.0203e-01,  2.2442e-01,  1.3185e-01,  4.8007e-01],\n",
       "         [ 2.4549e+00, -1.1149e+00,  1.3117e+00, -2.3741e+00, -1.4196e+00]],\n",
       "\n",
       "        [[-8.7446e-01,  1.2346e+00,  3.4694e+00, -2.1092e+00,  2.4723e+00],\n",
       "         [ 8.1480e-02,  2.6153e-01, -5.5364e-01, -3.4624e-03,  4.2223e-01],\n",
       "         [-6.7161e-01,  7.2215e-01,  3.6370e-01, -1.0077e-01,  3.6898e-01]],\n",
       "\n",
       "        [[ 2.7225e+00,  1.7054e+00,  4.5947e+00,  4.8942e+00, -6.9139e+00],\n",
       "         [ 6.1219e-01, -2.4888e+00, -6.8519e-01, -9.9073e-01,  3.0328e-01],\n",
       "         [-1.0087e+00,  1.4470e-01, -2.2284e+00, -1.1533e-01,  6.5225e+00]],\n",
       "\n",
       "        [[ 7.8706e-01, -1.9401e+00, -3.1415e+00, -2.4070e-01,  3.3773e+00],\n",
       "         [-8.5277e-01,  2.5588e+00,  4.7917e+00, -2.0185e+00, -2.6582e+00],\n",
       "         [ 3.2146e+00, -1.8742e+00, -2.7787e+00,  9.6017e-01,  3.0441e-01]],\n",
       "\n",
       "        [[-4.0002e+00, -2.2168e+00, -4.9551e-01,  2.6480e+00,  1.1355e+00],\n",
       "         [-3.8213e+00, -3.0871e+00,  3.8947e-01,  1.4108e+00,  7.9226e-01],\n",
       "         [ 4.9656e+00,  5.7757e+00, -2.9026e+00,  2.4843e-01, -1.3760e+00]],\n",
       "\n",
       "        [[ 4.5413e-01,  4.4979e-01, -4.6994e-01, -5.8940e-01,  1.1004e+00],\n",
       "         [ 2.1313e+00,  1.8204e+00, -1.4939e+00,  2.8134e+00,  3.0617e+00],\n",
       "         [-2.5437e+00,  2.8709e+00, -2.2823e+00, -3.1998e+00,  1.6599e+00]],\n",
       "\n",
       "        [[-2.8873e-01, -1.7395e+00,  2.4952e-01,  6.6666e-01,  2.8723e-01],\n",
       "         [ 4.3253e-01,  2.2155e+00, -4.4014e-02, -1.0128e+00, -7.6245e-01],\n",
       "         [ 6.5165e-01,  2.1312e+00, -1.6484e+00, -3.1213e-01,  2.7483e-01]],\n",
       "\n",
       "        [[ 2.9708e-01, -2.0220e+00,  6.7524e-01, -4.1507e-01,  8.3264e-01],\n",
       "         [-1.0691e+00, -2.4005e+00,  6.0016e-01, -1.1639e+00,  1.5150e+00],\n",
       "         [ 1.0988e+00, -6.5220e-02, -2.2620e+00,  9.6525e-01, -9.5812e-01]]])"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.bmm(x15, x16)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor(-0.9199), tensor([[ 1.0819, -0.3676],\n",
       "         [-0.2451,  1.0594]]), tensor([[-1.1824, -1.0863],\n",
       "         [ 1.5532,  0.3215]]))"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x17 = torch.randn(2,2)\n",
    "x18 = torch.randn(2,2)\n",
    "\n",
    "torch.dot(x17.view(-1), x18.view(-1)), x17, x18"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.3637122500000002"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1.7038 *  -0.6295 + -1.6000 *  -1.0304 +  1.4366 * -0.0231 + -0.9917 * 0.1807"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(-0.9199)"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.dot(x17.view(-1), x18.view(-1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([[0.4929, 0.8539, 0.4242, 0.0949],\n",
       "         [0.1302, 0.3532, 0.3893, 0.5571],\n",
       "         [0.3879, 0.6845, 0.3337, 0.8670]]), tensor([[0.4929, 0.1302, 0.3879],\n",
       "         [0.8539, 0.3532, 0.6845],\n",
       "         [0.4242, 0.3893, 0.3337],\n",
       "         [0.0949, 0.5571, 0.8670]]))"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x19  = torch.rand(3,4)\n",
    "\n",
    "x19, x19.t()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([[-0.5665,  0.8205, -0.0769],\n",
       "         [-0.4313, -0.3747, -0.8207],\n",
       "         [-0.7022, -0.4318,  0.5661]]),\n",
       " tensor([1.6865, 0.6069, 0.1842]),\n",
       " tensor([[-0.3603,  0.3100,  0.4061],\n",
       "         [-0.6622,  0.4492,  0.1732],\n",
       "         [-0.3810,  0.0957, -0.8858],\n",
       "         [-0.5353, -0.8324,  0.1428]]),\n",
       " tensor([[0.4929, 0.8539, 0.4242, 0.0949],\n",
       "         [0.1302, 0.3532, 0.3893, 0.5571],\n",
       "         [0.3879, 0.6845, 0.3337, 0.8670]]))"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u, s, v = torch.svd(x19)\n",
    "u, s, v, x19"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(4.8170e-07)"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.dist(x19, torch.mm(torch.mm(u, torch.diag(s)), v.t()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "# Tensor Data Type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0.6148, 0.3463],\n",
       "        [0.9456, 0.6276]])"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x20 = torch.rand(2,2)\n",
    "x20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([1, 1])"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x20  = torch.LongTensor([1,1])\n",
    "x20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([1., 1.])"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x20.float()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([1., 1.], dtype=torch.float64)"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x20.double()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([1, 1], dtype=torch.uint8)"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x20.byte()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([1, 1])"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([1, 1])"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x20 = x20.cpu()\n",
    "x20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1], dtype=int64)"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x20.numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0.2762, 0.6077],\n",
       "        [0.3506, 0.6249],\n",
       "        [0.0808, 0.2736]], dtype=torch.float64)"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.from_numpy(np.random.rand(3,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "cuda",
   "language": "python",
   "name": "cuda"
  },
  "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.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}