00.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "8950d066-e62b-427d-b69d-6f8deec74435",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.9.1\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "print(torch.__version__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "0f2074cf-2252-4c2b-9d19-3c876c4c5052",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "device(type='cuda')"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.device('cuda')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "ad37962a-a612-4a57-a26b-3ebf8b4aa131",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sat Jul  8 09:46:48 2023       \n",
      "+-----------------------------------------------------------------------------+\n",
      "| NVIDIA-SMI 510.47.03    Driver Version: 510.47.03    CUDA Version: 11.6     |\n",
      "|-------------------------------+----------------------+----------------------+\n",
      "| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n",
      "| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n",
      "|                               |                      |               MIG M. |\n",
      "|===============================+======================+======================|\n",
      "|   0  NVIDIA GeForce ...  On   | 00000000:26:00.0  On |                  N/A |\n",
      "| 57%   54C    P2    47W / 170W |   2435MiB / 12288MiB |     39%      Default |\n",
      "|                               |                      |                  N/A |\n",
      "+-------------------------------+----------------------+----------------------+\n",
      "                                                                               \n",
      "+-----------------------------------------------------------------------------+\n",
      "| Processes:                                                                  |\n",
      "|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\n",
      "|        ID   ID                                                   Usage      |\n",
      "|=============================================================================|\n",
      "|    0   N/A  N/A      4532      G   /usr/lib/xorg/Xorg                208MiB |\n",
      "|    0   N/A  N/A     11117      G   /usr/bin/gnome-shell              106MiB |\n",
      "|    0   N/A  N/A     18117      G   ...features=BackForwardCache       85MiB |\n",
      "|    0   N/A  N/A     18139      G   ...AAAAAAAAA= --shared-files       27MiB |\n",
      "|    0   N/A  N/A     18527      G   ...381817144388157433,262144      141MiB |\n",
      "|    0   N/A  N/A    282620      C   ...c/anaconda3/bin/python3.8     1859MiB |\n",
      "+-----------------------------------------------------------------------------+\n"
     ]
    }
   ],
   "source": [
    "!nvidia-smi"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "52c48444-f6bb-4726-97fb-759fedb6bdea",
   "metadata": {},
   "source": [
    "## Introduction to Tensors\n",
    "\n",
    "### Creating tensors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "9e69548a-b580-43a8-88be-ad418926961f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(7)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# scalar\n",
    "\n",
    "scalar = torch.tensor(7)\n",
    "scalar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "7fd2843d-c0f0-44db-bc6f-37292ded7479",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "scalar.ndim # finding the no. of dimentions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "c0617546-f934-43f3-8113-85e329b966b3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "scalar.item() # just get the data in the tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "394d9071-6cc4-45e8-b95d-b5ee582da3bb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([7, 7])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Vector\n",
    "vector = torch.tensor([7,7])\n",
    "vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "684bb586-b88c-499d-8c5a-aa36f6ba73f9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vector.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "68310dae-fccf-44d4-a705-95e90f0e48dd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([2])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vector.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "34adcfa0-7123-4016-9e03-7f7bdcdecdf9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Matrix\n",
    "MATRIX = torch.tensor(\n",
    "    [\n",
    "        [7,8],\n",
    "        [8,9]\n",
    "    ]\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "22789011-b9bb-4895-b17f-c82e166bf54a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([2, 2])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "MATRIX.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "c2af1739-2dd6-46e9-879a-4b97521fa871",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "MATRIX.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "d267e728-4c98-4c73-8f14-3bb6643a8c1b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tensor\n",
    "\n",
    "TENSOR = torch.tensor([[[1,2,3,4],[5,6,5,4],[6,8,9,4]]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "9452bffd-1ab7-4d07-9bc4-1f4e12a6b71e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[[1, 2, 3, 4],\n",
       "         [5, 6, 5, 4],\n",
       "         [6, 8, 9, 4]]])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "TENSOR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "c18dd547-b934-47ed-a991-074285b0ed4b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 3, 4])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "TENSOR.shape # first dimension, second is row, third is element in row"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "e1a17f3f-0d69-4d9e-82c0-c732b3bc3dfb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "TENSOR.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "23804375-49f1-4a55-90b4-dedf1f70f394",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([6, 8, 9, 4])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "TENSOR[0][2]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "698973fe-be95-478d-aea2-56860b2a04cc",
   "metadata": {},
   "source": [
    "### Random Tensor\n",
    "\n",
    "Why Random Tensors?\n",
    "This stf is important becz the way many neural networks learn is that they start with tensors full of random numbers and the adjust those random numbers to better represent the data\n",
    "\n",
    "`Start with random Numbers -> Look at data -> update random numbers -> look at data\n",
    "Update the output data`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "2689bb7c-a72b-45db-b78d-aed3a5bbd1c6",
   "metadata": {},
   "outputs": [],
   "source": [
    "rdm_tensor = torch.rand(3,4) # rows, columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "3d2de266-df8b-468f-8b1d-fecbccc6f903",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([3, 4])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rdm_tensor.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "54cf0c9f-82c7-450f-93dd-2b1a81564739",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rdm_tensor.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "cca29a61-87f8-45ef-a50c-9f5894506415",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0.4610, 0.9728, 0.4959, 0.9452],\n",
       "        [0.8538, 0.9498, 0.1322, 0.0813],\n",
       "        [0.2930, 0.9809, 0.6850, 0.6469]])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rdm_tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "d4fc8479-c5ea-4f36-8901-9d500803e75e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(torch.Size([3, 484, 224]), 3)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create random tensor with similar shape to image tensor\n",
    "random_image_size_tensor = torch.rand(size=(3,484,224)) # height, width, color\n",
    "random_image_size_tensor.shape,random_image_size_tensor.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "4f66f3be-9ec1-41a2-b670-5c1bf0e211ad",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(484, 484)"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(random_image_size_tensor[0]),len(random_image_size_tensor[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d25bd45-7811-4338-9c4b-01ace0b26ca5",
   "metadata": {},
   "source": [
    "### Tensors with ones and zeros"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "2cc62154-e793-4141-82c7-06a553f8e2f4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[1., 1., 1., 1.],\n",
       "        [1., 1., 1., 1.],\n",
       "        [1., 1., 1., 1.]])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ones_tensor = torch.ones(3,4)\n",
    "ones_tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "b1f2ff92-8939-4bc6-a188-f6ca8eff9898",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0., 0., 0., 0.],\n",
       "        [0., 0., 0., 0.],\n",
       "        [0., 0., 0., 0.]])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zeros_tensor = torch.zeros(3,4)\n",
    "zeros_tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "bb8705a0-3e08-4c6e-b2a0-f0b7d82f2d22",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0., 0., 0., 0.],\n",
       "        [0., 0., 0., 0.],\n",
       "        [0., 0., 0., 0.]])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rdm_tensor * zeros_tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "0dc17296-d423-4df7-90bc-d96b7c8be726",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.float32"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ones_tensor.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "04a7387e-8226-4c01-b04d-aa0d12434bf2",
   "metadata": {},
   "source": [
    "### Range"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "fed044bb-0983-4cb9-92ec-fc0c46cef6b2",
   "metadata": {},
   "outputs": [],
   "source": [
    "one_to_ten = torch.arange(start=1,end=11,step=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "a722bfc6-9b86-46c6-815d-56ad861fb41f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "one_to_ten\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "191d87d7-8894-4e9d-9d18-784e0215f23d",
   "metadata": {},
   "outputs": [],
   "source": [
    "ten_zeros = torch.zeros_like(input=one_to_ten)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "01804807-14f7-4112-a1bd-6e2a0a1d5b75",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ten_zeros"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d527815-6338-44f1-8401-78b32455e70a",
   "metadata": {},
   "source": [
    "### Tensor Datatypes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "98174ad9-f5bc-490a-9c72-facff1dfc5ba",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([3., 6., 9.], device='cuda:0', requires_grad=True)"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Float 32 tensor\n",
    "float_32_tensor = torch.tensor([3.0,6.0,9.0],dtype=None,device='cuda',requires_grad=True)\n",
    "float_32_tensor\n",
    "# lower the bit no. the faster the data can be proccessed\n",
    "# requires_grad means whther or not ot track the tensors gradient"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "7722a478-780c-42a7-b980-f687e3eabb57",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.float32"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float_32_tensor.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "35ced7c2-3dbf-4827-80e2-b3b8b055feff",
   "metadata": {},
   "outputs": [],
   "source": [
    "float_16_tensor = float_32_tensor.type(torch.float16)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "d07b4532-a8de-474c-8bdd-1c4e30b016d5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([3., 6., 9.], device='cuda:0', dtype=torch.float16,\n",
       "       grad_fn=<CopyBackwards>)"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float_16_tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "a1e61dc5-4e0e-4364-bbd4-c3018a4e9eec",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([ 9., 36., 81.], device='cuda:0', grad_fn=<MulBackward0>)"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float_16_tensor * float_32_tensor"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "045d1d17-fc1c-4e4d-8eb0-99d78035372c",
   "metadata": {},
   "source": [
    "## Geting infor from tensor\n",
    "\n",
    "Datatype - `tensor.dtype`\n",
    "\n",
    "Shape - `tensor.shape`\n",
    "\n",
    "Device - `tensor.device`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "598cd701-9f5b-4f32-8cbb-afa0f3ed7a60",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0.1329, 0.4664, 0.5542, 0.7325],\n",
       "        [0.6650, 0.8874, 0.8003, 0.1305],\n",
       "        [0.0612, 0.3378, 0.3317, 0.1508]])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a tensor\n",
    "some_tensor = torch.rand(3,4)\n",
    "some_tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "66e459e0-7683-42db-bbc5-515e28eda8f8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[0.1329, 0.4664, 0.5542, 0.7325],\n",
      "        [0.6650, 0.8874, 0.8003, 0.1305],\n",
      "        [0.0612, 0.3378, 0.3317, 0.1508]])\n",
      "torch.float32\n",
      "torch.Size([3, 4])\n",
      "cpu\n"
     ]
    }
   ],
   "source": [
    "print(some_tensor)\n",
    "print(some_tensor.dtype)\n",
    "print(some_tensor.size())\n",
    "print(some_tensor.device)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2cacfed-2b1f-41d5-a81e-be37f81a67e0",
   "metadata": {},
   "source": [
    "# Manipulating Tensors\n",
    "\n",
    "Tensor operations include:\n",
    "\n",
    "- Addition\n",
    "- Subtraction\n",
    "- Multiplication (Element wise)\n",
    "- Division\n",
    "- Matrix Multiplication"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "f26f044d-7b11-4123-9fda-c6c92d7a8373",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([11, 12, 13])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Addition\n",
    "\n",
    "tensor = torch.tensor([1,2,3])\n",
    "tensor + 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "4b8f6c8f-587c-4321-8c65-15e8f0dd77ed",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([10, 20, 30])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Multiplication\n",
    "\n",
    "tensor * 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "90409e20-4807-4ef8-b27c-abb843f909fd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([-9, -8, -7])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Subtraction\n",
    "\n",
    "tensor - 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "21ca3429-902f-4121-80a6-8caccb3089a6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([0.6667, 1.3333, 2.0000])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Division\n",
    "\n",
    "tensor / 1.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "1c5ebbc4-e5b3-41d5-a6a8-a178c9972653",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([-9, -8, -7])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Torch builtin functions\n",
    "\n",
    "torch.mul(tensor,10)\n",
    "torch.div(tensor,1.5)\n",
    "torch.add(tensor,10)\n",
    "torch.subtract(tensor,10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "186d9d2b-506e-4456-87b4-e87ce7658b2e",
   "metadata": {},
   "source": [
    "### Matrix multiplication\n",
    "\n",
    "Two main ways to perform multiplication in neural networks and deep learning:\n",
    "    \n",
    "    1. Element Wise Multiplication\n",
    "    2. Matrix Multiplication\n",
    "    \n",
    "2 Rules when doing matrix multiplication \n",
    "\n",
    "1. The inner dimmensions must match\n",
    "* (3,2) * (2,3) [This works]\n",
    "* (2,3) * (2,3) [Wont work]\n",
    "\n",
    "2. The out put matrix is of the outer dimensions\n",
    "* `(2,3) @ (3,2)` the output is (2,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "03d975a0-0619-49bf-96b7-ff8cdfd5039e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 114 µs, sys: 50 µs, total: 164 µs\n",
      "Wall time: 145 µs\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "tensor(14)"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%time\n",
    "torch.matmul(tensor, tensor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "0ddff137-b221-465f-a62d-18e723cb7f01",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([1, 4, 9])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tensor*tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "e78e13d8-d780-49b5-8e75-faecd6d80276",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([1, 2, 3])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "974e5538-6ab0-42b0-b951-da4deeb46ef1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 475 µs, sys: 0 ns, total: 475 µs\n",
      "Wall time: 338 µs\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# Matricx multiplication by hadnd\n",
    "value = 0\n",
    "for i in range(len(tensor)):\n",
    "    value += tensor[i] * tensor[i]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40b9a8b1-6796-44e6-b07c-1cfbed28ee69",
   "metadata": {},
   "source": [
    "### Most common erros in DL\n",
    "\n",
    "- Shape Errors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "b87b9dc8-04da-4712-8278-57a3f616c0da",
   "metadata": {},
   "outputs": [],
   "source": [
    "tensor_A = torch.tensor([\n",
    "        [1,2],\n",
    "        [3,4],\n",
    "        [5,6]\n",
    "])\n",
    "\n",
    "tensor_B = torch.tensor([\n",
    "        [7,8],\n",
    "        [8,11],\n",
    "        [9,12]\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "5d8ba200-b096-4221-ba34-6f84fc32697b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[ 29,  26,  32],\n",
       "        [ 65,  60,  72],\n",
       "        [101,  94, 112]])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.matmul(tensor_A,tensor_B.view(2,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "caa018a3-76ac-45d1-b75b-86a836cf4b4b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([[1, 3, 5],\n",
       "         [2, 4, 6]]),\n",
       " tensor([[1, 2],\n",
       "         [3, 4],\n",
       "         [5, 6]]))"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tensor_A.T, tensor_A"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa0e1099-253a-42cd-89d4-e871f846d89e",
   "metadata": {},
   "source": [
    "#### Transporse switches the axes of an tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "43f3f373-e456-4cb5-9569-beb3eac1ec44",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([[ 7,  8,  9],\n",
       "         [ 8, 11, 12]]),\n",
       " tensor([[ 7,  8],\n",
       "         [ 8, 11],\n",
       "         [ 9, 12]]))"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tensor_B.T,tensor_B"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dcc5387c-3aa5-4700-b59b-ab81ee1c72d4",
   "metadata": {},
   "source": [
    "### Finding the Min Max Mean and SUm of Tensors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "cd962c6a-faf5-4c5d-8182-45b3afb1b963",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = torch.arange(0,100,10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "381772fc-f131-4e05-ba1a-89f0f056c192",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([ 0, 10, 20, 30, 40, 50, 60, 70, 80, 90])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "ab229472-6583-4e90-b251-a3d3bb37b2f7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(0)"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.min()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "77e0bc82-d6c4-40e5-85ff-c91c7bf23739",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(90)"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "6085ab3e-0d6d-4cce-9119-588010ee6d1e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(45.)"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# requires a tensor of float or complex types\n",
    "x.type(torch.float32).mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "58996dfd-2839-49a6-8464-a2972b6811ab",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(450)"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30a3caf7-e843-443d-b3fe-d6f7d5a63eb7",
   "metadata": {},
   "source": [
    "### Finding the positional min and max"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "44ac8664-d7c2-480c-b1d6-e112b9a95389",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(9)"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.argmax()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "26a89833-49e7-4258-90d3-cbb7f5c72c40",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(0)"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.argmin()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42726bab-065f-4761-8350-02c99bbbc04f",
   "metadata": {},
   "source": [
    "## Reshaping, stacking, squeezing, unsqueezing tensors\n",
    "\n",
    "* Reshaping - reshapes an input tensor to a defined shape\n",
    "* View - Return a view of an input tensor of certain shape but keep the same memeory as the orgiiganl tensor\n",
    "* Stacking - combine multiple tensors on top of each other (vstack) or side by side (hstack)\n",
    "* Squeezing - removes all `1` dimensions from a tensor\n",
    "* Unsqueeze - add a `1` dimension to a target tensor\n",
    "* Permute - Return a view of the input with dimensions permuted (swapped in a certain way)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "074eb809-751d-4ecd-8b48-af48f4e58c35",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = torch.arange(1,10)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "bd08683e-3c5f-4478-b060-9abb9bc52bc7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([9])"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "eaae41cc-be49-45ad-8ea1-83f907e2e27a",
   "metadata": {},
   "outputs": [],
   "source": [
    "x_reshape = x.reshape(1,9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "aba1e09d-bdb0-4715-9c4d-a246b5b56a8d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[1, 2, 3, 4, 5, 6, 7, 8, 9]])"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_reshape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "e90228cc-7e26-4d1f-838e-ae9e667be629",
   "metadata": {},
   "outputs": [],
   "source": [
    "z = x.view(1,9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "a7fb110a-7a2c-4065-8eb8-faa55a996b85",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 9])"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "5aa525f9-f1f9-4fde-a0aa-2819c29a34b4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([9])"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "d3a3a093-e38f-43da-96ba-d74f30b1d325",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([[5, 2, 3, 4, 5, 6, 7, 8, 9]]), tensor([5, 2, 3, 4, 5, 6, 7, 8, 9]))"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# view shares the same memory\n",
    "z[0][0] = 5\n",
    "z,x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "f3726bf9-f74e-496f-99e7-bfaf52292914",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Stack tensors on top\n",
    "x_stacked = torch.stack([x,x,x,x],dim=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "6805630f-42cb-4b6c-9f5f-a75f677aa4d2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[5, 5, 5, 5],\n",
       "        [2, 2, 2, 2],\n",
       "        [3, 3, 3, 3],\n",
       "        [4, 4, 4, 4],\n",
       "        [5, 5, 5, 5],\n",
       "        [6, 6, 6, 6],\n",
       "        [7, 7, 7, 7],\n",
       "        [8, 8, 8, 8],\n",
       "        [9, 9, 9, 9]])"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_stacked"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "9e77b61d-9553-4f23-8fc8-efc7b097708c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# torch.squeeze() remove all 1 dimensional shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "e0b6178e-c39a-48cb-8399-f7f1729da3f6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[5, 2, 3, 4, 5, 6, 7, 8, 9]])"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_reshape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "760bcdb0-284a-4cea-b2fb-055eaf3d041a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 9])"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_reshape.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "2509314a-a685-4098-b00a-ed14a4e2f77e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([9])"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_reshape.squeeze().shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "67cadf3d-833b-47c4-870c-741634e9cf1f",
   "metadata": {},
   "outputs": [],
   "source": [
    "x_squeezed = x_reshape.squeeze()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "bc00f9df-61a2-460f-a056-2f42db9d9547",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[5, 2, 3, 4, 5, 6, 7, 8, 9]])"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_squeezed.unsqueeze(dim=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "c7a982ee-59f0-4d55-8821-e6807f133b05",
   "metadata": {},
   "outputs": [],
   "source": [
    "# premute - changes the dimensions of a tensors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "d692e67c-662e-4f9b-b435-718fac2c8b71",
   "metadata": {},
   "outputs": [],
   "source": [
    "x_original = torch.rand(size=(224,224,3)) #height, width ,color channels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "3120b07e-96b3-45cd-97b5-7ec3ea9ddbc0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(torch.Size([3, 224, 224]), torch.Size([224, 224, 3]))"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.permute(x_original,(2,0,1)).shape, x_original.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c464d1b0-ba53-4e3f-baac-3dd7e518a24c",
   "metadata": {},
   "source": [
    "### Indexing\n",
    "\n",
    "Indexing with pytorch is similar with numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "c26167d0-689a-45a1-83a2-9bc3f5313ed4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a tensor\n",
    "\n",
    "x = torch.arange(1,10).reshape(1,3,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "b47d3b30-926c-4ffc-836f-23f5451517be",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[[1, 2, 3],\n",
       "         [4, 5, 6],\n",
       "         [7, 8, 9]]])"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "1da4a5af-90f8-4bd5-b351-06c7df4388ff",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[1, 2, 3],\n",
       "        [4, 5, 6],\n",
       "        [7, 8, 9]])"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "fc319b4b-e6e9-4965-ac98-7fbe8fe15641",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([1, 2, 3])"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[0][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "9e397736-5db3-419b-8533-cfe3eb7355fb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(1)"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[0][0][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "53843709-57ea-4ee7-8394-51868ed0719b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(9)"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[0][2][2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "25ffa03e-483d-4f64-b538-cea5f45537de",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[3, 6, 9]])"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[:,:,2]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "62fc549f-56d5-413b-ac78-582718f09d92",
   "metadata": {},
   "source": [
    "## Pytorch tensors & Numpy\n",
    "\n",
    "NumPy is a popular scientifica python numeical computing library\n",
    "\n",
    "And becase of this Pytorch has functionalty to interact with it\n",
    "\n",
    "* Data in Numpy, want in pytorch tensor -> `torch.from_numpy(ndarry)`\n",
    "* Pytorch tensors -> Numpy `torch.Tensor.numpy()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "0bf8a257-0033-4d1b-a16c-1ea3a3e5e9cf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([1., 2., 3., 4., 5., 6., 7.]),\n",
       " tensor([1., 2., 3., 4., 5., 6., 7.], dtype=torch.float64))"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# NumPy array to tensor\n",
    "import numpy as np\n",
    "\n",
    "array = np.arange(1.0,8.0)\n",
    "tensor = torch.from_numpy(array) # when converting from numpy, pyotrch reflects numpy's default datatype of float64\n",
    "array,tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "id": "c1618b28-59fc-4443-9e53-5c96190b319a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.float64"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tensor.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "c62c880b-8c6a-4602-8560-7a55d169a2a3",
   "metadata": {},
   "outputs": [],
   "source": [
    "array = array +1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "id": "4beb990e-7ba2-4851-9491-3b11a962e86e",
   "metadata": {},
   "outputs": [],
   "source": [
    "tensor = torch.ones(7)\n",
    "numpy_tensor = tensor.numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "id": "06ad544c-02aa-461b-b617-89ffd63c2697",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([1., 1., 1., 1., 1., 1., 1.], dtype=float32),\n",
       " tensor([1., 1., 1., 1., 1., 1., 1.]))"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numpy_tensor,tensor"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "481e24b8-176c-4581-b1d1-6255ec2106f3",
   "metadata": {},
   "source": [
    "## Reproducibility (trying to take random out of random)\n",
    "\n",
    "In short how a neural netowrk learns:\n",
    "\n",
    "`start with random numbers -> tensor operations -> update random numbers to try and make them better representations`\n",
    "\n",
    "To reduce the randomness in neural networks and PyTorch comes the concept of a **random seed**\n",
    "\n",
    "Essentially what the random seed does is flavor the randomness. It makes it constant"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "id": "af510c58-7e50-4297-a265-857186547979",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[0.8823, 0.9150, 0.3829, 0.9593],\n",
      "        [0.3904, 0.6009, 0.2566, 0.7936],\n",
      "        [0.9408, 0.1332, 0.9346, 0.5936]])\n",
      "tensor([[0.8694, 0.5677, 0.7411, 0.4294],\n",
      "        [0.8854, 0.5739, 0.2666, 0.6274],\n",
      "        [0.2696, 0.4414, 0.2969, 0.8317]])\n",
      "tensor([[False, False, False, False],\n",
      "        [False, False, False, False],\n",
      "        [False, False, False, False]])\n"
     ]
    }
   ],
   "source": [
    "random_A = torch.rand(3,4)\n",
    "random_B = torch.rand(3,4)\n",
    "\n",
    "print(random_A)\n",
    "print(random_B)\n",
    "print(random_A == random_B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "id": "89077ad1-543e-47cc-9da6-139e4ec9b119",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[0.8823, 0.9150, 0.3829, 0.9593],\n",
      "        [0.3904, 0.6009, 0.2566, 0.7936],\n",
      "        [0.9408, 0.1332, 0.9346, 0.5936]])\n",
      "tensor([[0.8823, 0.9150, 0.3829, 0.9593],\n",
      "        [0.3904, 0.6009, 0.2566, 0.7936],\n",
      "        [0.9408, 0.1332, 0.9346, 0.5936]])\n",
      "tensor([[True, True, True, True],\n",
      "        [True, True, True, True],\n",
      "        [True, True, True, True]])\n"
     ]
    }
   ],
   "source": [
    "RANDOM_SEED = 42\n",
    "torch.manual_seed(RANDOM_SEED)\n",
    "random_A = torch.rand(3,4)\n",
    "torch.manual_seed(RANDOM_SEED)\n",
    "random_B = torch.rand(3,4)\n",
    "\n",
    "print(random_A)\n",
    "print(random_B)\n",
    "print(random_A == random_B)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41ecc91f-4051-4049-bdbc-fe9b11a6fcdd",
   "metadata": {},
   "source": [
    "## Accessing GPU\n",
    "\n",
    "GPUs= faster computation on numbers, thanks to CUDA + NVIDIA hardware + Pytorch working BTS "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "id": "c7ce05cb-10dd-43e1-b177-f2640f27d4be",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.cuda.is_available()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "867fec4f-0880-4b15-a259-c64a7366f114",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}