00_pytorchFundemental.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.1.0+cu121\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "print(torch.__version__)\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(7)\n"
     ]
    }
   ],
   "source": [
    "#  scalar\n",
    "scalar = torch.tensor(7) \n",
    "print(scalar)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "torch.Size([])\n"
     ]
    }
   ],
   "source": [
    "print(scalar.ndim)\n",
    "print(scalar.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    }
   ],
   "source": [
    "print(scalar.item())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([1, 1])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Vector\n",
    "vector = torch.tensor([1, 1])\n",
    "vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([2])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vector.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[ 7,  8],\n",
       "        [ 9, 10]])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# MATRIX\n",
    "matrix = torch.tensor([[7, 8], \n",
    "                       [9, 10]])\n",
    "matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([7, 8])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matrix[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([2, 2])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matrix.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[[1, 2, 3],\n",
       "         [3, 6, 9],\n",
       "         [2, 4, 5]]])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# TENSOR\n",
    "TENSOR = torch.tensor([[[1, 2, 3], \n",
    "                        [3, 6, 9], \n",
    "                        [2, 4, 5]]])\n",
    "TENSOR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "TENSOR.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 3, 3])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "TENSOR.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!-- @format -->\n",
    "\n",
    "### random tensors\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[[0.4192, 0.6505, 0.8707, 0.7762, 0.4384, 0.7625, 0.7584, 0.2986,\n",
       "          0.4444, 0.5725],\n",
       "         [0.1939, 0.0687, 0.3900, 0.1717, 0.9909, 0.6002, 0.5573, 0.2611,\n",
       "          0.7636, 0.2843],\n",
       "         [0.1098, 0.8175, 0.3171, 0.2965, 0.1633, 0.6913, 0.6010, 0.6905,\n",
       "          0.2867, 0.4322],\n",
       "         [0.1162, 0.4072, 0.3670, 0.3914, 0.2031, 0.9484, 0.9979, 0.4773,\n",
       "          0.6628, 0.9078],\n",
       "         [0.3184, 0.9212, 0.1854, 0.6223, 0.8760, 0.8543, 0.2196, 0.0240,\n",
       "          0.1472, 0.4860],\n",
       "         [0.6208, 0.7380, 0.9827, 0.5752, 0.8668, 0.2052, 0.7634, 0.2882,\n",
       "          0.7803, 0.6282],\n",
       "         [0.3792, 0.5716, 0.4608, 0.2687, 0.7936, 0.0730, 0.1628, 0.4226,\n",
       "          0.5467, 0.0778],\n",
       "         [0.0502, 0.3965, 0.6332, 0.3830, 0.8988, 0.1366, 0.7428, 0.0530,\n",
       "          0.4816, 0.6932],\n",
       "         [0.3206, 0.6868, 0.0236, 0.1952, 0.0546, 0.5023, 0.1755, 0.6230,\n",
       "          0.4826, 0.7845],\n",
       "         [0.7827, 0.4183, 0.2908, 0.8124, 0.8294, 0.5796, 0.6264, 0.5769,\n",
       "          0.4187, 0.5328]],\n",
       "\n",
       "        [[0.6842, 0.1343, 0.8877, 0.6190, 0.2801, 0.0389, 0.5776, 0.4227,\n",
       "          0.0636, 0.2367],\n",
       "         [0.2980, 0.1769, 0.6800, 0.2204, 0.2327, 0.8698, 0.7865, 0.6993,\n",
       "          0.6315, 0.7424],\n",
       "         [0.3974, 0.7314, 0.3257, 0.3543, 0.5787, 0.1769, 0.4872, 0.7540,\n",
       "          0.3809, 0.3464],\n",
       "         [0.1654, 0.5020, 0.0939, 0.1256, 0.8546, 0.6567, 0.6164, 0.9072,\n",
       "          0.1141, 0.1622],\n",
       "         [0.9076, 0.3884, 0.9504, 0.0804, 0.6040, 0.4157, 0.1943, 0.5593,\n",
       "          0.4697, 0.6675],\n",
       "         [0.2602, 0.8316, 0.5848, 0.6879, 0.9924, 0.8541, 0.8274, 0.2042,\n",
       "          0.6502, 0.0109],\n",
       "         [0.7357, 0.8379, 0.0727, 0.8691, 0.4862, 0.4864, 0.5911, 0.9874,\n",
       "          0.3791, 0.7654],\n",
       "         [0.2180, 0.4634, 0.7959, 0.2917, 0.1157, 0.9304, 0.0495, 0.9792,\n",
       "          0.0404, 0.3340],\n",
       "         [0.2049, 0.2980, 0.1775, 0.6253, 0.1203, 0.7186, 0.1629, 0.8074,\n",
       "          0.4219, 0.6466],\n",
       "         [0.6955, 0.8973, 0.6853, 0.1744, 0.1515, 0.8359, 0.2000, 0.7829,\n",
       "          0.6202, 0.9613]],\n",
       "\n",
       "        [[0.8503, 0.0391, 0.2929, 0.3477, 0.4468, 0.9965, 0.4210, 0.7481,\n",
       "          0.4194, 0.5467],\n",
       "         [0.9042, 0.2641, 0.5842, 0.3635, 0.1873, 0.7457, 0.6352, 0.2284,\n",
       "          0.1146, 0.3499],\n",
       "         [0.3891, 0.5104, 0.1694, 0.1817, 0.3347, 0.0016, 0.0876, 0.6297,\n",
       "          0.7085, 0.5398],\n",
       "         [0.3976, 0.7251, 0.7048, 0.1420, 0.2829, 0.1794, 0.1342, 0.9950,\n",
       "          0.8896, 0.0951],\n",
       "         [0.1662, 0.1863, 0.5385, 0.4199, 0.0403, 0.1677, 0.7041, 0.3945,\n",
       "          0.7538, 0.8279],\n",
       "         [0.8618, 0.2927, 0.5788, 0.0435, 0.4259, 0.0317, 0.6725, 0.3671,\n",
       "          0.3437, 0.0274],\n",
       "         [0.2364, 0.9720, 0.8975, 0.7412, 0.6720, 0.3633, 0.4885, 0.0082,\n",
       "          0.5180, 0.9003],\n",
       "         [0.9892, 0.9445, 0.4632, 0.2570, 0.9038, 0.4560, 0.4671, 0.2828,\n",
       "          0.6646, 0.8445],\n",
       "         [0.1946, 0.9491, 0.8460, 0.2421, 0.5347, 0.1965, 0.7748, 0.2039,\n",
       "          0.4015, 0.4260],\n",
       "         [0.4839, 0.0396, 0.5164, 0.5399, 0.3974, 0.0857, 0.1994, 0.1819,\n",
       "          0.0165, 0.6426]],\n",
       "\n",
       "        [[0.7684, 0.9930, 0.5548, 0.1462, 0.4036, 0.4694, 0.5721, 0.4899,\n",
       "          0.0736, 0.7975],\n",
       "         [0.4224, 0.9242, 0.8639, 0.2766, 0.7288, 0.8744, 0.6716, 0.9057,\n",
       "          0.4526, 0.8041],\n",
       "         [0.1197, 0.8299, 0.7405, 0.6993, 0.9885, 0.8024, 0.4573, 0.3288,\n",
       "          0.1605, 0.0443],\n",
       "         [0.9033, 0.6905, 0.9419, 0.3849, 0.4419, 0.6338, 0.1832, 0.8615,\n",
       "          0.0925, 0.2781],\n",
       "         [0.4427, 0.4945, 0.0967, 0.6933, 0.3201, 0.0390, 0.9861, 0.1185,\n",
       "          0.3713, 0.3777],\n",
       "         [0.6953, 0.0588, 0.2629, 0.8231, 0.2478, 0.7849, 0.2034, 0.3361,\n",
       "          0.7382, 0.3644],\n",
       "         [0.0306, 0.7451, 0.9816, 0.5032, 0.0738, 0.1952, 0.4900, 0.0465,\n",
       "          0.8681, 0.1532],\n",
       "         [0.6791, 0.7140, 0.9279, 0.6263, 0.3144, 0.0489, 0.4086, 0.5296,\n",
       "          0.8255, 0.3422],\n",
       "         [0.1469, 0.2159, 0.0092, 0.7964, 0.3234, 0.1432, 0.3224, 0.1753,\n",
       "          0.9720, 0.2941],\n",
       "         [0.9216, 0.5705, 0.4807, 0.4150, 0.2299, 0.4067, 0.2396, 0.7897,\n",
       "          0.2047, 0.6243]],\n",
       "\n",
       "        [[0.7630, 0.7416, 0.9196, 0.7015, 0.8599, 0.9877, 0.0124, 0.0465,\n",
       "          0.3274, 0.3111],\n",
       "         [0.9534, 0.7989, 0.6617, 0.6564, 0.1229, 0.4741, 0.8246, 0.2177,\n",
       "          0.3814, 0.9035],\n",
       "         [0.6073, 0.4732, 0.2778, 0.4265, 0.3863, 0.8661, 0.6788, 0.5775,\n",
       "          0.2645, 0.0890],\n",
       "         [0.5557, 0.6348, 0.5428, 0.9869, 0.6265, 0.5805, 0.1451, 0.6772,\n",
       "          0.3311, 0.6580],\n",
       "         [0.9001, 0.5849, 0.4837, 0.4830, 0.1354, 0.9248, 0.4056, 0.9956,\n",
       "          0.6021, 0.0512],\n",
       "         [0.2694, 0.5693, 0.9652, 0.5860, 0.6091, 0.7683, 0.9608, 0.3354,\n",
       "          0.7728, 0.1955],\n",
       "         [0.9485, 0.6705, 0.6715, 0.3916, 0.9796, 0.9692, 0.0030, 0.3495,\n",
       "          0.2964, 0.0114],\n",
       "         [0.0529, 0.5099, 0.6831, 0.3614, 0.2922, 0.5102, 0.1917, 0.0536,\n",
       "          0.9370, 0.1901],\n",
       "         [0.2971, 0.5296, 0.4448, 0.0544, 0.4727, 0.8327, 0.8919, 0.0019,\n",
       "          0.5458, 0.7275],\n",
       "         [0.3120, 0.6092, 0.0345, 0.7134, 0.8379, 0.3801, 0.3378, 0.9602,\n",
       "          0.7860, 0.2155]],\n",
       "\n",
       "        [[0.5265, 0.4905, 0.1145, 0.3554, 0.9941, 0.2222, 0.6770, 0.1863,\n",
       "          0.3302, 0.4544],\n",
       "         [0.4269, 0.8192, 0.0198, 0.6478, 0.1331, 0.4252, 0.6787, 0.8512,\n",
       "          0.0627, 0.4920],\n",
       "         [0.4237, 0.6768, 0.7173, 0.1612, 0.4997, 0.7315, 0.0403, 0.7577,\n",
       "          0.7117, 0.1072],\n",
       "         [0.1255, 0.7634, 0.7618, 0.3500, 0.3028, 0.0841, 0.9561, 0.4867,\n",
       "          0.0274, 0.4052],\n",
       "         [0.9369, 0.3812, 0.2910, 0.6518, 0.0714, 0.8839, 0.2900, 0.4810,\n",
       "          0.1967, 0.0192],\n",
       "         [0.0283, 0.8709, 0.3734, 0.1719, 0.4221, 0.7018, 0.4923, 0.5195,\n",
       "          0.2350, 0.8692],\n",
       "         [0.8111, 0.4986, 0.1896, 0.9923, 0.2073, 0.7064, 0.5355, 0.5481,\n",
       "          0.4818, 0.5448],\n",
       "         [0.2762, 0.7221, 0.1356, 0.4001, 0.9695, 0.1434, 0.8682, 0.1738,\n",
       "          0.7320, 0.7394],\n",
       "         [0.3284, 0.1749, 0.8909, 0.6128, 0.9104, 0.7876, 0.9949, 0.4990,\n",
       "          0.0439, 0.7359],\n",
       "         [0.5174, 0.1666, 0.7073, 0.8601, 0.3802, 0.9206, 0.7630, 0.8714,\n",
       "          0.3281, 0.8334]],\n",
       "\n",
       "        [[0.2458, 0.6540, 0.7083, 0.0191, 0.8882, 0.1218, 0.9967, 0.6517,\n",
       "          0.6698, 0.0702],\n",
       "         [0.2379, 0.9190, 0.8762, 0.5899, 0.3051, 0.4867, 0.6376, 0.3601,\n",
       "          0.1058, 0.3888],\n",
       "         [0.8714, 0.9951, 0.7668, 0.7721, 0.1285, 0.3152, 0.9287, 0.8842,\n",
       "          0.5873, 0.6450],\n",
       "         [0.1351, 0.2186, 0.5968, 0.9693, 0.7993, 0.0588, 0.9522, 0.4673,\n",
       "          0.0201, 0.2741],\n",
       "         [0.5115, 0.7179, 0.0823, 0.9676, 0.0903, 0.7297, 0.5414, 0.1681,\n",
       "          0.4473, 0.5558],\n",
       "         [0.2223, 0.7481, 0.9704, 0.6901, 0.5637, 0.4118, 0.5585, 0.6153,\n",
       "          0.6809, 0.7943],\n",
       "         [0.5266, 0.1735, 0.8648, 0.5621, 0.7641, 0.2674, 0.4803, 0.5685,\n",
       "          0.1696, 0.8355],\n",
       "         [0.3026, 0.4588, 0.5551, 0.7268, 0.7927, 0.5929, 0.9949, 0.9891,\n",
       "          0.0694, 0.1684],\n",
       "         [0.5775, 0.5239, 0.6077, 0.9572, 0.8174, 0.4205, 0.5543, 0.7691,\n",
       "          0.4940, 0.3689],\n",
       "         [0.9002, 0.9316, 0.0386, 0.1587, 0.8412, 0.7935, 0.1294, 0.8470,\n",
       "          0.8717, 0.6728]],\n",
       "\n",
       "        [[0.1453, 0.3113, 0.1238, 0.9461, 0.4414, 0.1340, 0.7688, 0.8277,\n",
       "          0.3946, 0.6492],\n",
       "         [0.5917, 0.6419, 0.6347, 0.3018, 0.7237, 0.0661, 0.5614, 0.4127,\n",
       "          0.2906, 0.2530],\n",
       "         [0.4005, 0.0920, 0.7298, 0.9696, 0.0110, 0.0345, 0.7547, 0.1372,\n",
       "          0.4408, 0.8176],\n",
       "         [0.6060, 0.7998, 0.4449, 0.8945, 0.5869, 0.7655, 0.8541, 0.7271,\n",
       "          0.3368, 0.0384],\n",
       "         [0.5130, 0.7526, 0.7536, 0.1319, 0.9013, 0.0843, 0.9247, 0.6975,\n",
       "          0.1821, 0.1213],\n",
       "         [0.5017, 0.9356, 0.0936, 0.3970, 0.3268, 0.7768, 0.8635, 0.9601,\n",
       "          0.5608, 0.8188],\n",
       "         [0.6364, 0.1585, 0.5140, 0.0554, 0.0353, 0.5388, 0.7013, 0.7154,\n",
       "          0.8946, 0.6845],\n",
       "         [0.3124, 0.0075, 0.9190, 0.4466, 0.6373, 0.2208, 0.5465, 0.9161,\n",
       "          0.8900, 0.1360],\n",
       "         [0.4632, 0.1271, 0.7010, 0.4382, 0.6028, 0.0502, 0.0750, 0.6403,\n",
       "          0.5318, 0.0338],\n",
       "         [0.0256, 0.4875, 0.4993, 0.6251, 0.1504, 0.7501, 0.5973, 0.4466,\n",
       "          0.7790, 0.1927]],\n",
       "\n",
       "        [[0.9524, 0.6459, 0.9639, 0.0887, 0.4704, 0.6262, 0.9978, 0.4988,\n",
       "          0.0345, 0.9903],\n",
       "         [0.8067, 0.1092, 0.0607, 0.9499, 0.3747, 0.3743, 0.7023, 0.1681,\n",
       "          0.8804, 0.1431],\n",
       "         [0.2049, 0.9267, 0.9121, 0.2779, 0.9976, 0.9101, 0.5372, 0.4926,\n",
       "          0.4430, 0.2143],\n",
       "         [0.6182, 0.8295, 0.1548, 0.4344, 0.8864, 0.3479, 0.9989, 0.2259,\n",
       "          0.1217, 0.8941],\n",
       "         [0.1291, 0.1409, 0.5804, 0.8145, 0.2834, 0.1040, 0.7949, 0.4036,\n",
       "          0.0653, 0.5297],\n",
       "         [0.2357, 0.9834, 0.0614, 0.3765, 0.5918, 0.5287, 0.3490, 0.0917,\n",
       "          0.1146, 0.3344],\n",
       "         [0.3463, 0.6127, 0.9214, 0.8208, 0.2106, 0.3258, 0.1376, 0.7134,\n",
       "          0.4152, 0.9179],\n",
       "         [0.5373, 0.2952, 0.4760, 0.6069, 0.6837, 0.4807, 0.5513, 0.5427,\n",
       "          0.9194, 0.8812],\n",
       "         [0.9715, 0.9514, 0.9817, 0.3198, 0.6378, 0.1892, 0.7952, 0.7117,\n",
       "          0.6238, 0.4098],\n",
       "         [0.7655, 0.3429, 0.4566, 0.3282, 0.9434, 0.5516, 0.3787, 0.9383,\n",
       "          0.1217, 0.2567]],\n",
       "\n",
       "        [[0.9276, 0.2680, 0.0606, 0.4261, 0.4073, 0.6498, 0.7455, 0.5574,\n",
       "          0.9283, 0.7961],\n",
       "         [0.1377, 0.6343, 0.0210, 0.2148, 0.5189, 0.0838, 0.4108, 0.4315,\n",
       "          0.0965, 0.6485],\n",
       "         [0.7303, 0.2725, 0.6592, 0.9044, 0.1629, 0.9673, 0.9202, 0.2901,\n",
       "          0.8010, 0.2118],\n",
       "         [0.7041, 0.8670, 0.2145, 0.3684, 0.6359, 0.9529, 0.7438, 0.5437,\n",
       "          0.1953, 0.0508],\n",
       "         [0.3129, 0.5977, 0.0761, 0.8983, 0.3856, 0.4203, 0.1633, 0.8757,\n",
       "          0.0233, 0.2235],\n",
       "         [0.5950, 0.7855, 0.3970, 0.0875, 0.0826, 0.3385, 0.7141, 0.3492,\n",
       "          0.7995, 0.0943],\n",
       "         [0.2722, 0.1179, 0.7029, 0.4732, 0.0096, 0.1190, 0.3631, 0.5313,\n",
       "          0.8613, 0.3972],\n",
       "         [0.0629, 0.7239, 0.4455, 0.8754, 0.6931, 0.3031, 0.1837, 0.6398,\n",
       "          0.7707, 0.1895],\n",
       "         [0.1436, 0.0255, 0.0426, 0.5820, 0.5624, 0.4721, 0.4679, 0.6634,\n",
       "          0.8084, 0.0181],\n",
       "         [0.4425, 0.8760, 0.7865, 0.6334, 0.6313, 0.9941, 0.6992, 0.4450,\n",
       "          0.9924, 0.1368]]])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create a random\n",
    "random_tensor = torch.rand(10, 10, 10)\n",
    "random_tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random_tensor.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(torch.Size([224, 224, 3]), 3)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random_image_tensor = torch.rand(size=(224, 224, 3))\n",
    "random_image_tensor.shape, random_image_tensor.ndim"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!-- @format -->\n",
    "\n",
    "### Zeros and Ones\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0., 0., 0., 0.],\n",
       "        [0., 0., 0., 0.],\n",
       "        [0., 0., 0., 0.]])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a tensor with all zeros\n",
    "zero = torch.zeros(3, 4)\n",
    "zero"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0., 0., 0., 0.],\n",
       "        [0., 0., 0., 0.],\n",
       "        [0., 0., 0., 0.]])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random_tensor = torch.rand(3, 4)\n",
    "zero * random_tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[1., 1., 1., 1.],\n",
       "        [1., 1., 1., 1.],\n",
       "        [1., 1., 1., 1.]])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create tensor of all ones\n",
    "ones = torch.ones(3, 4)\n",
    "ones"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!-- @format -->\n",
    "\n",
    "### Creating a range of tensors and tensors-like\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([  0,  67, 134, 201, 268, 335, 402, 469, 536, 603, 670, 737, 804, 871,\n",
       "        938])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Use torch.range\n",
    "torch.arange(start=0, end=1000, step=67)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10])\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "one_to_ten = torch.arange(1, 11)\n",
    "print(one_to_ten)\n",
    "torch.zeros_like(one_to_ten)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!-- @format -->\n",
    "\n",
    "### Tensor Datatype\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([3., 6., 9.])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Float 32 Dtype\n",
    "float32_tensor = torch.tensor([3., 6., 9.], dtype=None, device=None, requires_grad=False)\n",
    "float32_tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.float32"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float32_tensor.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([3., 6., 9.], dtype=torch.float16)"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float16_tensor = float32_tensor.type(torch.float16)\n",
    "float16_tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([ 9., 36., 81.])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float16_tensor * float32_tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([3, 6, 9])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int32_tensor = torch.tensor([3,6,9], dtype=torch.long)\n",
    "int32_tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([ 9., 36., 81.])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int32_tensor * float32_tensor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!-- @format -->\n",
    "\n",
    "### Getting info from tensors\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0.4972, 0.3517, 0.1032, 0.6565],\n",
       "        [0.4961, 0.3789, 0.2876, 0.0404],\n",
       "        [0.3050, 0.9981, 0.4039, 0.1146]])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create a tensor\n",
    "some_tensor = torch.rand(3, 4)\n",
    "some_tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[0.4972, 0.3517, 0.1032, 0.6565],\n",
      "        [0.4961, 0.3789, 0.2876, 0.0404],\n",
      "        [0.3050, 0.9981, 0.4039, 0.1146]])\n",
      "Datatype of tensor: torch.float32\n",
      "Shape of tensor: torch.Size([3, 4])\n",
      "Device tensor is on: cpu\n"
     ]
    }
   ],
   "source": [
    "# Find out details about some tensor\n",
    "print(some_tensor)\n",
    "print(f\"Datatype of tensor: {some_tensor.dtype}\")\n",
    "print(f\"Shape of tensor: {some_tensor.shape}\")\n",
    "print(f\"Device tensor is on: {some_tensor.device}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!-- @format -->\n",
    "\n",
    "### Manipulating Tensors (Tensor Operation)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[100.1735, 100.0924, 100.5006, 100.6214],\n",
       "        [100.8861, 100.7019, 100.3885, 100.1297],\n",
       "        [100.1472, 100.6554, 100.5544, 100.6615]])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tmp = torch.rand(3, 4)\n",
    "tmp + 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[17.3501,  9.2374, 50.0569, 62.1448],\n",
       "        [88.6135, 70.1943, 38.8481, 12.9746],\n",
       "        [14.7211, 65.5361, 55.4349, 66.1511]])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tmp * 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[-0.3265, -0.4076,  0.0006,  0.1214],\n",
       "        [ 0.3861,  0.2019, -0.1115, -0.3703],\n",
       "        [-0.3528,  0.1554,  0.0543,  0.1615]])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tmp - 0.5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!-- @format -->\n",
    "\n",
    "### Matrix Multiplication\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0.9792, 0.9518, 0.9018],\n",
       "        [1.0608, 1.1845, 1.0606],\n",
       "        [0.9719, 1.1861, 1.2153]])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.matmul(torch.rand(3, 4), torch.rand(4, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0.5062, 0.1766, 0.2769, 0.5376],\n",
       "        [0.8030, 0.2542, 0.5733, 0.9254],\n",
       "        [0.9472, 0.2851, 0.6976, 1.1233],\n",
       "        [1.0086, 0.3167, 0.7114, 1.1656]])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tensorA = torch.rand(3, 4)\n",
    "tensorB = torch.rand(3, 4)\n",
    "torch.matmul(tensorA.T, tensorB)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!-- @format -->\n",
    "\n",
    "### Min & Max & Sum & Mean & etc.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([ 0, 10, 20, 30, 40, 50, 60, 70, 80, 90])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a tensor\n",
    "x = torch.arange(0, 100, 10)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor(0), tensor(0))"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.min(x), x.min()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor(90), tensor(90))"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.max(x), x.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(45.)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.mean(x.type(torch.float32))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor(450), tensor(450))"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.sum(x), x.sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!-- @format -->\n",
    "\n",
    "### Find positional Min and Max\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([ 0, 10, 20, 30, 40, 50, 60, 70, 80, 90]), tensor(0), tensor(9))"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x, x.argmin(), x.argmax()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!-- @format -->\n",
    "\n",
    "### Reshaping, Stacking, Squeezing and unsqueezing tensors\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([1, 2, 3, 4, 5, 6, 7, 8, 9]), torch.Size([9]))"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import torch\n",
    "x = torch.arange(1, 10)\n",
    "x, x.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[1, 2, 3],\n",
       "        [4, 5, 6],\n",
       "        [7, 8, 9]])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_reshaped = x.reshape(3, 3)\n",
    "x_reshaped"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([[1, 2, 3],\n",
       "         [4, 5, 6],\n",
       "         [7, 8, 9]]),\n",
       " torch.Size([3, 3]))"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z = x.view(3, 3)\n",
    "z, z.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([[5, 2, 3],\n",
       "         [5, 5, 6],\n",
       "         [5, 8, 9]]),\n",
       " tensor([5, 2, 3, 5, 5, 6, 5, 8, 9]))"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z[:, 0] = 5\n",
    "z, x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[5, 5, 5, 5],\n",
       "        [2, 2, 2, 2],\n",
       "        [3, 3, 3, 3],\n",
       "        [5, 5, 5, 5],\n",
       "        [5, 5, 5, 5],\n",
       "        [6, 6, 6, 6],\n",
       "        [5, 5, 5, 5],\n",
       "        [8, 8, 8, 8],\n",
       "        [9, 9, 9, 9]])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_stacked = torch.stack([x, x, x, x], dim=1)\n",
    "x_stacked"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[5, 2, 3, 5, 5, 6, 5, 8, 9]])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_reshaped = x.reshape(1, 9)\n",
    "x_reshaped"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([5, 2, 3, 5, 5, 6, 5, 8, 9]), torch.Size([9]))"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_reshaped.squeeze(), x_reshaped.squeeze().shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[5],\n",
       "        [2],\n",
       "        [3],\n",
       "        [5],\n",
       "        [5],\n",
       "        [6],\n",
       "        [5],\n",
       "        [8],\n",
       "        [9]])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_squeezed = x_reshaped.squeeze()\n",
    "x_unsqueezed = x_squeezed.unsqueeze(dim=1)\n",
    "x_unsqueezed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([224, 224, 3])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = torch.rand(224, 224, 3)\n",
    "x.size()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([3, 224, 224])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.permute(x, (2, 0, 1)).shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!-- @format -->\n",
    "\n",
    "### Indexing\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([[[1, 2, 3],\n",
       "          [4, 5, 6],\n",
       "          [7, 8, 9]]]),\n",
       " torch.Size([1, 3, 3]))"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import torch\n",
    "x = torch.arange(1, 10).reshape(1, 3, 3)\n",
    "x, x.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[1, 2, 3],\n",
       "        [4, 5, 6],\n",
       "        [7, 8, 9]])"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# index\n",
    "x[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([1, 2, 3])"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[0][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([1])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[:, 0, 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([1., 2., 3., 4., 5., 6., 7., 8., 9.]),\n",
       " tensor([1., 2., 3., 4., 5., 6., 7., 8., 9.]))"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import torch\n",
    "import numpy as np\n",
    "arr = np.arange(1., 10.)\n",
    "tensor = torch.from_numpy(arr).type(torch.float32)\n",
    "arr, tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([ 2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.]),\n",
       " tensor([1., 2., 3., 4., 5., 6., 7., 8., 9.]))"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = arr + 1\n",
    "arr, tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([1., 1., 1., 1., 1., 1., 1., 1.]),\n",
       " array([1., 1., 1., 1., 1., 1., 1., 1.], dtype=float32))"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Tensor to Numpy\n",
    "tensor = torch.ones(8)\n",
    "numpy_tensor = tensor.numpy()\n",
    "tensor, numpy_tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([2., 2., 2., 2., 2., 2., 2., 2.]),\n",
       " array([1., 1., 1., 1., 1., 1., 1., 1.], dtype=float32))"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tensor = tensor * 2\n",
    "tensor, numpy_tensor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!-- @format -->\n",
    "\n",
    "### Reproducbility\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([[0.2152, 0.7937, 0.5576, 0.7206],\n",
       "         [0.1614, 0.2229, 0.4402, 0.7524],\n",
       "         [0.8354, 0.8753, 0.6936, 0.0296]]),\n",
       " tensor([[0.5208, 0.5620, 0.1147, 0.9473],\n",
       "         [0.4103, 0.0565, 0.2727, 0.7350],\n",
       "         [0.3802, 0.7110, 0.7033, 0.2123]]),\n",
       " tensor([[False, False, False, False],\n",
       "         [False, False, False, False],\n",
       "         [False, False, False, False]]))"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import torch\n",
    "randA = torch.rand(3, 4)\n",
    "randB = torch.rand(3, 4)\n",
    "randA, randB, randA == randB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[True, True, True, True],\n",
       "        [True, True, True, True],\n",
       "        [True, True, True, True]])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Random and reproducible tensors\n",
    "import torch\n",
    "RANDOM_SEED = 114514\n",
    "torch.manual_seed(RANDOM_SEED)\n",
    "randA = torch.rand(3, 4)\n",
    "torch.manual_seed(RANDOM_SEED)\n",
    "randB = torch.rand(3, 4)\n",
    "randA == randB"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!-- @format -->\n",
    "\n",
    "### Running tensors on GPUs\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import torch\n",
    "torch.cuda.is_available()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'cuda'"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "device"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.cuda.device_count()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!-- @format -->\n",
    "\n",
    "### Put tensors on GPU\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([1., 2., 3.], device='cuda:0')"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tensor = torch.tensor([1., 2., 3.])\n",
    "tensorOnGPU = tensor.to(device)\n",
    "tensorOnGPU"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 2., 3.], dtype=float32)"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# move back to cpu\n",
    "tensorOnCPU = tensorOnGPU.to(\"cpu\")\n",
    "tensorOnCPU.numpy()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "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.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}