00_pytorch_fundmentals.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/alchemistklk/pytorch_tutorial/blob/master/00_pytorch_fundmentals.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "fuVa0_luPIhj",
        "outputId": "867de498-c1f2-4b46-b578-ca14afb7f1a3"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'2.2.1+cu121'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 2
        }
      ],
      "source": [
        "import torch\n",
        "torch.__version__"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Introduction to Tensors\n",
        "### Creating tensors"
      ],
      "metadata": {
        "id": "mxcgmB12kx18"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# scalar\n",
        "scalar = torch.tensor(7)\n",
        "scalar"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WATEqYTgM40y",
        "outputId": "b3ada0c9-c64e-4892-e3f0-056290a31493"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor(7)"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "scalar.ndim"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "U5DYtnfTX7DJ",
        "outputId": "6f916eb2-26cf-4c48-cb37-1ffa06910874"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Get tensor back as Python int\n",
        "scalar.item()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cIcKV8tzYLOV",
        "outputId": "05c85171-f3bc-4460-bbcd-9dd2ca8ee617"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "7"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Vector\n",
        "vector = torch.tensor([7, 7])\n",
        "vector"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BJekPtJiYd9J",
        "outputId": "cc460987-eb33-4681-aef3-1eb7d1e9cb00"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([7, 7])"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# the dimention equals the number of square brackets\n",
        "vector.ndim"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZHSW4tDwZwMM",
        "outputId": "58e158ee-e389-4e6b-e6b5-4fdcf3d7effd"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "vector.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xWO-MAuPaKRQ",
        "outputId": "4cd48d4d-7dd6-4cc1-fd5a-0a7286ee52a2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.Size([2])"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# MATRIX\n",
        "MATRIX = torch.tensor([[7, 8]\n",
        "                       ,[9, 10]])"
      ],
      "metadata": {
        "id": "5M9TVOMTaUO-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "MATRIX[1]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aiHHFsNjdlUx",
        "outputId": "4f833ce2-9d9a-4c99-a6e7-57f2349d2ca4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([ 9, 10])"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "MATRIX.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DQFvsFt1doBJ",
        "outputId": "0eaf5ed5-0583-4476-94d1-53f7d1148c12"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.Size([2, 2])"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Tensor\n",
        "TENSOR = torch.tensor([[[1, 3, 5]\n",
        "                        ,[2, 4, 6]\n",
        "                        , [3, 6, 9]]])\n",
        "TENSOR"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YXMH4IXadtLK",
        "outputId": "d02bebb4-3fe6-4ac0-861f-1e1beb6af56a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[[1, 3, 5],\n",
              "         [2, 4, 6],\n",
              "         [3, 6, 9]]])"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "TENSOR.ndim"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TlAlPZmmeQxO",
        "outputId": "2dba2d4c-2689-4cdb-bf52-a558dbae3c30"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "TENSOR.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "csDa2o4BetXw",
        "outputId": "f6777414-5151-4810-ef38-ab2418bf8e68"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.Size([1, 3, 3])"
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "TENSOR[0]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dIx4LRjWez3p",
        "outputId": "cff08bb9-dc55-4332-9e1e-94b47af5b94a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[1, 3, 5],\n",
              "        [2, 4, 6],\n",
              "        [3, 6, 9]])"
            ]
          },
          "metadata": {},
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Random Tensors\n",
        "Why random tensors?\n",
        "Random tensors are important because the way many neural networks learn is that they start with tensors full of number then adjust those random numbers to better represent the data.\n",
        "Crux of deep learning\n",
        "`random data -> look at data -> update random numbers -> look at data -> update random numbers`\n",
        "Torch random tensors:"
      ],
      "metadata": {
        "id": "Q4jxsF12n-Dq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Creating a random tensor of size(3, 4)\n",
        "random_tensor = torch.rand(2, 3, 4)\n",
        "random_tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nxH20CyNpiNM",
        "outputId": "5fe95c04-88db-40a3-df6f-ac1d04d8a16e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[[0.3987, 0.2139, 0.2003, 0.3163],\n",
              "         [0.2526, 0.0673, 0.7217, 0.6954],\n",
              "         [0.6862, 0.2140, 0.4969, 0.1486]],\n",
              "\n",
              "        [[0.9319, 0.8105, 0.8587, 0.4542],\n",
              "         [0.0280, 0.4079, 0.9013, 0.7508],\n",
              "         [0.8389, 0.1453, 0.3676, 0.3354]]])"
            ]
          },
          "metadata": {},
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "gMAb-xdst8yw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "random_tensor.ndim"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "k84mr3XYq0Xl",
        "outputId": "7ffb39fa-7359-454a-bf06-98fb1cdd61ee"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "random_tensor.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5RnjLOgLq3vL",
        "outputId": "926557a7-96e3-4606-9437-13be22f4e755"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.Size([2, 3, 4])"
            ]
          },
          "metadata": {},
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Zeros and Ones"
      ],
      "metadata": {
        "id": "T01QbtdSuMeR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "zeros = torch.zeros(size=(3, 4))\n",
        "zeros"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XvL8EgH5uZfE",
        "outputId": "ab53079d-bf2a-43be-c067-81a00fe1c5f9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[0., 0., 0., 0.],\n",
              "        [0., 0., 0., 0.],\n",
              "        [0., 0., 0., 0.]])"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "ones = torch.ones(size=(3, 4))\n",
        "ones"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZZ_6olalumb2",
        "outputId": "638e817b-5b0b-4b3a-df96-93b39e45850c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[1., 1., 1., 1.],\n",
              "        [1., 1., 1., 1.],\n",
              "        [1., 1., 1., 1.]])"
            ]
          },
          "metadata": {},
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Creating a range of tensors and tensors-like"
      ],
      "metadata": {
        "id": "tHVB_LlH1h6-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Use torch.arange(), you want a range of number\n",
        "one_to_ten = torch.arange(1, 10, 1)\n",
        "one_to_ten"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KZ6arPox1I1r",
        "outputId": "8d5c8951-d443-45f4-dc0e-87869f99f2cf"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([1, 2, 3, 4, 5, 6, 7, 8, 9])"
            ]
          },
          "metadata": {},
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Creating tensor with same shape\n",
        "ten_zeros = torch.zeros_like(input=one_to_ten)\n",
        "ten_zeros"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3b39Yq4u1_vQ",
        "outputId": "1530f366-b5a9-4587-aa8e-8d63612f8238"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([0, 0, 0, 0, 0, 0, 0, 0, 0])"
            ]
          },
          "metadata": {},
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Tensor datatype\n",
        "**Note:** Tensor type is one one 3 big errors you'll run into with Pytorch & deep learning\n",
        "1. Tensors not right datatyoe\n",
        "2. Tensors not right shape\n",
        "3. Tensors not on the right device\n",
        "Precision in computing:\n",
        "todo:"
      ],
      "metadata": {
        "id": "OVU3glhI3W1i"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "float_32_tensor = torch.tensor([3.0, 6.0, 9.0],\n",
        "                               dtype=None, # what type is the tensor\n",
        "                               device=None,# what device is your tensor on\n",
        "                               requires_grad=False) # whether or not to track gradients with this tensors operation\n",
        "float_32_tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nUYdGjDp6oRz",
        "outputId": "250ad005-cebd-4301-ba4f-a202bf49d229"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([3., 6., 9.])"
            ]
          },
          "metadata": {},
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "float_32_tensor.dtype"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dCcbxusQ67BC",
        "outputId": "4a7a6368-f164-45fd-c4d3-9b74562fa24c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.float32"
            ]
          },
          "metadata": {},
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Covert the datatype of tensor\n",
        "float_16_tensor = float_32_tensor.type(torch.float16)\n",
        "float_16_tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "poaQZkYo6-Pv",
        "outputId": "e10aced8-826d-4471-f124-ae706f30f68f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([3., 6., 9.], dtype=torch.float16)"
            ]
          },
          "metadata": {},
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "varibale = float_16_tensor * float_32_tensor\n",
        "varibale.dtype"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dWrlnFjhCh5x",
        "outputId": "91f708b9-25e1-4e4e-af8b-7ab2b4e36969"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.float32"
            ]
          },
          "metadata": {},
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Getting information from tensors\n",
        "1. Tensor not right datatype - to get datatype from a tensor, use `tensor.dtype`\n",
        "2. Tensor not right shape - to get datatype from a tensor, use `tensor.shape`\n",
        "3. Tensor not on thr right device - to get device from a tensor, use `tensor.device`"
      ],
      "metadata": {
        "id": "t-_mdm6BEIzx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a tensor\n",
        "some_tensor = torch.rand(3, 4)\n",
        "some_tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5mxbaBQFEuoW",
        "outputId": "94917549-6587-4ac2-bc21-18b3d50831e3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[0.6933, 0.3853, 0.9863, 0.7598],\n",
              "        [0.6639, 0.2382, 0.0982, 0.3992],\n",
              "        [0.4451, 0.2196, 0.2093, 0.8918]])"
            ]
          },
          "metadata": {},
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Find out details about some tensor\n",
        "print(some_tensor)\n",
        "print(f\"Datatype of some_tensor is {some_tensor.dtype}\")\n",
        "print(f\"Shape of some_tensor is {some_tensor.shape}\")\n",
        "print(f\"device tensor is on {some_tensor.device}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bnXHB24BF8r1",
        "outputId": "f1e6b0ae-531f-4405-99af-9644e5aa62cb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([[0.6933, 0.3853, 0.9863, 0.7598],\n",
            "        [0.6639, 0.2382, 0.0982, 0.3992],\n",
            "        [0.4451, 0.2196, 0.2093, 0.8918]])\n",
            "Datatype of some_tensor is torch.float32\n",
            "Shape of some_tensor is torch.Size([3, 4])\n",
            "device tensor is on cpu\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Manipulating Tensors(tensor operations)\n",
        "Tensor operation includes:\n",
        "- Addition\n",
        "- Substraction\n",
        "- Multiplication(element-wise)\n",
        "- Division\n",
        "- Matrix multiplication\n"
      ],
      "metadata": {
        "id": "J7SyI_9B1KXa"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tensor = torch.tensor([1, 2, 3])"
      ],
      "metadata": {
        "id": "y0i8gMJ31ugY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Addition\n",
        "tensor + 10"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eaHpya-Q2wQr",
        "outputId": "a39409e5-6c7a-439e-d348-b10c077ccbcd"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([11, 12, 13])"
            ]
          },
          "metadata": {},
          "execution_count": 30
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Substraction\n",
        "tensor - 10"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OJjjCquK3ISA",
        "outputId": "c276edb6-05ed-4dbf-f53a-817ed9fd0667"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([-9, -8, -7])"
            ]
          },
          "metadata": {},
          "execution_count": 31
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Multiplication\n",
        "tensor * 10"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0y8L4v5e3LCd",
        "outputId": "7e44d637-da45-4cde-a5b4-568ddfb5eb54"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([10, 20, 30])"
            ]
          },
          "metadata": {},
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Division\n",
        "tensor / 10"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "W-N3zq2B3Oye",
        "outputId": "6ae65666-845f-4ef0-d9f2-8a167cae81fb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([0.1000, 0.2000, 0.3000])"
            ]
          },
          "metadata": {},
          "execution_count": 33
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Matrix Multiplication\n",
        "Two main way of performing multiplication in neural networks and deep learning:\n",
        "1. Element-wise multiplication\n",
        "2. Matrix multiplication(dot product)\n",
        "\n",
        "\n",
        "\n",
        "There are two main rules that performing matrix multiplication need to satisfy\n",
        "1. The **inner dimensions** must match\n",
        "  - (3, 2) @ (3, 2) won't work\n",
        "  - (3, 2) @ (2, 3) will work\n",
        "  - (2, 3) @ (3, 2) will work\n",
        "2. The resulting matrix has a shape of **outer dimensions**\n",
        "  - (2, 3) @ (3, 2) -> (2, 2)\n",
        "\n"
      ],
      "metadata": {
        "id": "39bC9A6X3XLU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "%%time\n",
        "torch.matmul(tensor, tensor)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hCsuNOAD6mw4",
        "outputId": "39f988e6-907d-4dc5-f367-5804055d665b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "CPU times: user 2.28 ms, sys: 48 µs, total: 2.33 ms\n",
            "Wall time: 9.31 ms\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor(14)"
            ]
          },
          "metadata": {},
          "execution_count": 34
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# tensor_A = torch.rand(2, 3)\n",
        "# tensor_B = torch.rand(2, 3)\n",
        "# print(f\"matmul result: {tensor_A @ tensor_B}\")"
      ],
      "metadata": {
        "id": "VTL6n-f56wfP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "tensor_A = torch.rand(2, 3)\n",
        "tensor_B = torch.rand(2, 3)\n",
        "print(f\"matmul result: {tensor_A @ tensor_B.T}\")\n",
        "output = torch.matmul(tensor_A, tensor_B.T)\n",
        "print(f\"The shape of resulting matrix: {output.size()}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "piixFkECBFvy",
        "outputId": "03dc27bf-a2d4-4549-c2b3-e8b4cc6d17fe"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "matmul result: tensor([[1.2284, 1.6164],\n",
            "        [0.9416, 1.2266]])\n",
            "The shape of resulting matrix: torch.Size([2, 2])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Finding the min, max, mean, sum, etc(tensor aggregation)"
      ],
      "metadata": {
        "id": "0Ye3JMvDCDme"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a tensor\n",
        "x = torch.arange(0, 100, 10)\n",
        "x.min()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OmENdOXACM9f",
        "outputId": "649791eb-d130-4169-df69-37b5f5021ef0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor(0)"
            ]
          },
          "metadata": {},
          "execution_count": 37
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x.max()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "o97r6lrFChbQ",
        "outputId": "69400998-e8e0-43ff-a5a4-2152782f32c3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor(90)"
            ]
          },
          "metadata": {},
          "execution_count": 38
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x.type(torch.float32 ).mean()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qiJc2rijCjFK",
        "outputId": "7029e2a4-a842-4a01-a8fb-cff8aa072d19"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor(45.)"
            ]
          },
          "metadata": {},
          "execution_count": 39
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Finding the positional min and max"
      ],
      "metadata": {
        "id": "V2vlouC7Eqil"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "c4LFn03bY3GV",
        "outputId": "773413fb-885f-4ac8-b8c7-35ae4421ceba"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([ 0, 10, 20, 30, 40, 50, 60, 70, 80, 90])"
            ]
          },
          "metadata": {},
          "execution_count": 40
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Find the positional in tensor that minimal value with argmin() -> returns index postion of target tensor where the minimum value occurs\n",
        "x.argmin()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tmxXZyTmY5FK",
        "outputId": "5d745f14-32e6-418a-ed89-9adc5d0a05f1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor(0)"
            ]
          },
          "metadata": {},
          "execution_count": 41
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x[0]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dQI1d-0HY8Xa",
        "outputId": "8006cb87-eff4-4cbb-dd6f-2826d0498356"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor(0)"
            ]
          },
          "metadata": {},
          "execution_count": 42
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x.argmax()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "goV5ovfLZw0N",
        "outputId": "6c5c2e61-afd1-4280-98a3-4e4f4c8120ea"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor(9)"
            ]
          },
          "metadata": {},
          "execution_count": 43
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Reshaping, viewing, stacking\n",
        "- Reshaping - reshape an input tensor to a define shape\n",
        "- View - Return a view of an input tensor of certain shape but **keep the same memory as the original tensor**\n",
        "- Stacking - combine multiple tensors as top of each other(vstack) or side by side (hstack)\n",
        "- Squeeze - 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 cerain way"
      ],
      "metadata": {
        "id": "QEvpNk9wZ9e2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = torch.arange(1, 10)\n",
        "x.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6O_wThuJaCuw",
        "outputId": "4191cb87-2f98-4710-bee9-aab4ea8fab6c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.Size([9])"
            ]
          },
          "metadata": {},
          "execution_count": 44
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x_reshaped = x.reshape(3, 3)\n",
        "x_reshaped = x.reshape(1, 9)"
      ],
      "metadata": {
        "id": "RDLU7N7xeD7y"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Change the view\n",
        "# Change z changes x (because a view of a tensor shares the same memory as the orginal memory)\n",
        "z = x_reshaped.view(1, 9)\n",
        "z[:, 0] = 5\n",
        "x_reshaped"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "g_TdmU3Tepwv",
        "outputId": "96c72eac-a522-41f8-83a1-e00eee5211ee"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[5, 2, 3, 4, 5, 6, 7, 8, 9]])"
            ]
          },
          "metadata": {},
          "execution_count": 46
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Stack tensors on the top of each other\n",
        "# vstack dim = 0; vstack dim = 1\n",
        "x_stacked = torch.stack([x, x, x, x], dim=1)\n",
        "x_stacked"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "38g5sgDXgC5Q",
        "outputId": "41df906e-7c5e-4787-f632-5e54c4bed5f8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "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]])"
            ]
          },
          "metadata": {},
          "execution_count": 47
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Squeezing, unsqueezing, permuting\n",
        "  - Squeezing: Returns a tensor with all specificed dimentions of `input` of size 1 removed\n",
        "  - Unsqueezing: Returns a new tensor with a dimension of size one inserted in specific position.\n",
        "  - Permute: Returns a view of originla tensor input with its dimensions permuted"
      ],
      "metadata": {
        "id": "DW-q2D9PcIEX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# torch.squeeze() - remove all single dimension from a target tensor\n",
        "print(f\"Previous tensor:{x_reshaped}\")\n",
        "print(f\"Previous shape: {x_reshaped.shape}\")\n",
        "\n",
        "x_squeeze = x_reshaped.squeeze()\n",
        "print(f\"\\nNew tensor:{x_squeeze}\")\n",
        "print(f\"New shape: {x_squeeze.shape}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "g2Kb4xCmdsCM",
        "outputId": "78b9ed58-ef23-4e61-c448-73408fa27327"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Previous tensor:tensor([[5, 2, 3, 4, 5, 6, 7, 8, 9]])\n",
            "Previous shape: torch.Size([1, 9])\n",
            "\n",
            "New tensor:tensor([5, 2, 3, 4, 5, 6, 7, 8, 9])\n",
            "New shape: torch.Size([9])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(f\"Previous tensor: {x_reshaped.squeeze()}\")\n",
        "print(f\"Previous shape: {x_reshaped.squeeze().shape}\")\n",
        "\n",
        "x_unsqueeze = x_reshaped.unsqueeze(dim = 0)\n",
        "print(f\"New tensor: {x_unsqueeze}\")\n",
        "print(f\"New shape: {x_unsqueeze.shape}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jdAIx6rcfwPP",
        "outputId": "7fa865ac-c05d-4fa7-ac15-c4df508baea2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Previous tensor: tensor([5, 2, 3, 4, 5, 6, 7, 8, 9])\n",
            "Previous shape: torch.Size([9])\n",
            "New tensor: tensor([[[5, 2, 3, 4, 5, 6, 7, 8, 9]]])\n",
            "New shape: torch.Size([1, 1, 9])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Rearrange the dimension of a target tensor in a specific order\n",
        "x_original = torch.rand(size=(224, 224, 3))\n",
        "x_permute = x_original.permute(2, 0, 1)\n",
        "print(f\"Previous shape: {x_original.shape}\")\n",
        "print(f\"New shape: {x_permute.shape}\")"
      ],
      "metadata": {
        "id": "q-LdaziUsWii",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8ddd75ac-f1f9-4de7-bc0b-d3d93ea8a5a3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Previous shape: torch.Size([224, 224, 3])\n",
            "New shape: torch.Size([3, 224, 224])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Indexing(Selecting data from tensors)\n",
        "Indexing with Pytorch is similar to indexing with Numpy"
      ],
      "metadata": {
        "id": "S7IUtWElt2UP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x_index = torch.arange(1, 10).reshape(1, 3, 3)\n",
        "x_index\n",
        "print(x_index[0][0][0])\n",
        "print(x_index)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gV_-rlW_uupd",
        "outputId": "7534343c-fc3f-46d5-b400-bd125f1910c3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor(1)\n",
            "tensor([[[1, 2, 3],\n",
            "         [4, 5, 6],\n",
            "         [7, 8, 9]]])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# You can use the \":\" to select \"all\" of a target dimension\n",
        "x_index[:,:, 0]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wZQj2XoxvcMq",
        "outputId": "33130b05-83f7-4358-f792-14dbf14db6dc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[1, 4, 7]])"
            ]
          },
          "metadata": {},
          "execution_count": 52
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Pytorch tensors & NumPy\n",
        "NumPy is a popular scentific Python numerical computing library\n",
        "Because of this, Pytorch has functionality to interact with it\n",
        "  - Data in NumPy, want in Pytorch tensor -> `torch.from_numpy()`\n",
        "  - Pytorch tensor -> NumPy -> `torch.Tensor.numpy()`\n"
      ],
      "metadata": {
        "id": "0RNIrPYqxLWB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "array = np.arange(1.0, 8.0)\n",
        "array.dtype"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8kpxg0aZybFi",
        "outputId": "e658585f-03c1-4c90-8be9-e9320cea87df"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "dtype('float64')"
            ]
          },
          "metadata": {},
          "execution_count": 53
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tensor = torch.from_numpy(array)\n",
        "tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bEK5Es57zQ-j",
        "outputId": "b9cd5f87-3813-4d6e-b73a-2e7459a10616"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([1., 2., 3., 4., 5., 6., 7.], dtype=torch.float64)"
            ]
          },
          "metadata": {},
          "execution_count": 54
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tensor = torch.ones(7)\n",
        "numpy_tensor = tensor.numpy()\n",
        "numpy_tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jHpcoo8hzXVQ",
        "outputId": "934a9423-5cef-48cb-c62a-456081226eb2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1., 1., 1., 1., 1., 1., 1.], dtype=float32)"
            ]
          },
          "metadata": {},
          "execution_count": 55
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Reproducbility(trying to take random out of random)\n",
        "In short how a neutal network learns:\n",
        "`start with random numbers -> tensor operations -> update random numbers to try and make them better representation -> again`\n",
        "\n",
        "To reduce the randomness in neural networks and Pytorch comes the concept of a **random seed**\n",
        "Essentially what the random seed does is \"flavour\" the randomness\n"
      ],
      "metadata": {
        "id": "xvYf1Cm90AFk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "MANUAL_SEED = 42\n",
        "torch.manual_seed(MANUAL_SEED)\n",
        "random_tensor_A = torch.rand(3, 4)\n",
        "torch.manual_seed(MANUAL_SEED)\n",
        "random_tensor_B = torch.rand(3, 4)\n",
        "print(random_tensor_A)\n",
        "print(random_tensor_B)\n",
        "print(random_tensor_A == random_tensor_B)"
      ],
      "metadata": {
        "id": "7Ley4H6ovjX3",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "db8aa6ca-8c8e-4d02-bd24-5dbbf05b2aa0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "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"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Running tensors and Pytorch objects on the GPU(and making faster computations)\n",
        "GPUs = faster computation on numbers, thanks to CUDA + NVIDIA hardware + Pytorch working behind the scenes to make every hunkydory"
      ],
      "metadata": {
        "id": "hAJ2OkzbNwGW"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### 1. Check GPU"
      ],
      "metadata": {
        "id": "LpxBepSLXzaa"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Setup device agnostic code\n",
        "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
        "device"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "42Vg84liQkW0",
        "outputId": "d6691b49-3fee-4290-9bd3-4f82140214f9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'cuda'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 59
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Count number of devices\n",
        "torch.cuda.device_count()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LcTbJFOmTl_Y",
        "outputId": "29859aca-116c-4632-f392-23c9e5a50636"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {},
          "execution_count": 60
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### 2. Putting tensors(and models) on GPU\n",
        "The reason why we want our tensors/models on the GPU is because using a GPU results in faster computations"
      ],
      "metadata": {
        "id": "-RX_vnqOVZe7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tensor = torch.tensor([1, 2, 3])\n",
        "print(tensor, tensor.device)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_LxqVcTWVwRf",
        "outputId": "7afa906a-d05d-4a24-8f8a-f051122eb649"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([1, 2, 3]) cpu\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Move tensor to GPU if available\n",
        "tensor_gpu = tensor.to(device)\n",
        "print(tensor_gpu, tensor_gpu.device)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HDcEsU1qV12C",
        "outputId": "879ecb15-fb49-4a72-e243-89511a105000"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([1, 2, 3], device='cuda:0') cuda:0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### 3. Use CPU to calculate"
      ],
      "metadata": {
        "id": "u9DpCk0kWj2m"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tensor_gpu.cpu().numpy()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "E93ilJcyYDID",
        "outputId": "14ebd34b-84ad-422c-a5ac-dcf3c6182441"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1, 2, 3])"
            ]
          },
          "metadata": {},
          "execution_count": 65
        }
      ]
    }
  ]
}