00_pytorch_fundamentals.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4",
      "authorship_tag": "ABX9TyOq31To4ZVra7axrlINmpO5",
      "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/ReImage-CollegeProject/Learn_PyTorch/blob/main/00_pytorch_fundamentals.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 00. pytorch fundamentals\n",
        "\n",
        "Resource notebook: https://www.learnpytorch.io/00_pytorch_fundamentals/\n",
        "\n",
        "\n",
        "\n",
        "Discussion: https://github.com/mrdbourke/pytorch-deep-learning/discussions"
      ],
      "metadata": {
        "id": "lY5_jR9d4rEj"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "devUxlfF4Gfn",
        "outputId": "96929634-3045-474a-fcae-7a2d54d037ff"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "hello world pytorch\n"
          ]
        }
      ],
      "source": [
        "print(\"hello world pytorch\")"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!nvidia-smi"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Z-ctQVRZ4ST0",
        "outputId": "7c919e4d-b3f1-4ed5-851e-0e7a0e9ad191"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "/bin/bash: line 1: nvidia-smi: command not found\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "print(torch.__version__)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uFgLciDz4him",
        "outputId": "4daeb285-285e-4f33-d5ad-c6b602c19100"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2.1.0+cu118\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt"
      ],
      "metadata": {
        "id": "EQe68Yzk50r8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Introduction to Tensor\n",
        "\n",
        "### creating tensors\n",
        "\n",
        "PyTorch tensors are created using `torch.tensor()` = https://pytorch.org/docs/stable/tensors.html"
      ],
      "metadata": {
        "id": "j-cdw71s6muA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# scalar\n",
        "\n",
        "scalar  = torch.tensor(7)\n",
        "scalar"
      ],
      "metadata": {
        "id": "7PWZAUix59PA",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c5538c38-f2a6-49a2-ca55-c0431e1ed12f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor(7)"
            ]
          },
          "metadata": {},
          "execution_count": 70
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "scalar.ndim       # scalar has 0 dimension so"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GOs8noIJ6wW0",
        "outputId": "c9e29e31-95fd-496e-e556-aaf0b42657a1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "metadata": {},
          "execution_count": 71
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Get tensor back as Python int\n",
        "\n",
        "scalar.item()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fXDEVl1h7XLd",
        "outputId": "b9f4178b-4ff4-418f-a291-7d089848de38"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "7"
            ]
          },
          "metadata": {},
          "execution_count": 72
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Vector\n",
        "vector = torch.tensor([7,7])\n",
        "vector"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YO6Z4eWy7qAC",
        "outputId": "042bf5f0-01fa-49e7-9ac5-24de7a0070ab"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([7, 7])"
            ]
          },
          "metadata": {},
          "execution_count": 73
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "vector.ndim\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "L70xGcE779Ia",
        "outputId": "70de6aec-08cb-4de9-cb8d-71d88092a6dd"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {},
          "execution_count": 74
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "vector.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LCb5ZsQx7_y-",
        "outputId": "27f0298e-0b54-46a3-b395-484d01ddce38"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.Size([2])"
            ]
          },
          "metadata": {},
          "execution_count": 75
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# MATRIX\n",
        "\n",
        "MATRIX = torch.tensor([[7, 8],\n",
        "                       [9, 10]])\n",
        "MATRIX"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "W3VFQQhM8Bq4",
        "outputId": "52528422-1145-4d0b-9365-09bfecd4dbe6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[ 7,  8],\n",
              "        [ 9, 10]])"
            ]
          },
          "metadata": {},
          "execution_count": 76
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "MATRIX.ndim"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KhSz_fs48bZF",
        "outputId": "6c25e3f7-dc0c-4542-c0e5-eb6c8fa5529e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {},
          "execution_count": 77
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "MATRIX[1]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3-SmGuO68lFL",
        "outputId": "e0a67fb7-69a8-4558-9d77-df9914462f9d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([ 9, 10])"
            ]
          },
          "metadata": {},
          "execution_count": 78
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "MATRIX.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XFT-Ge2K8now",
        "outputId": "7d654b2f-4d0b-45b3-fe0f-0266e108cc61"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.Size([2, 2])"
            ]
          },
          "metadata": {},
          "execution_count": 79
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Tensor"
      ],
      "metadata": {
        "id": "rCTr9v3Z9Drx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# TENSOR\n",
        "TENSOR = torch.tensor([[[1,2,3],\n",
        "                        [3,6,9],\n",
        "                        [2,4,5]]])\n",
        "\n",
        "TENSOR"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Wtoj7peP89br",
        "outputId": "8c050d45-3878-4342-d2df-c422f0038af8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[[1, 2, 3],\n",
              "         [3, 6, 9],\n",
              "         [2, 4, 5]]])"
            ]
          },
          "metadata": {},
          "execution_count": 80
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "TENSOR.ndim"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2YJGZznk9XsS",
        "outputId": "6aff1ffb-5423-41d0-8992-d85fde13c4f5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "metadata": {},
          "execution_count": 81
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "TENSOR.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "G6FkZKXcAnXv",
        "outputId": "e3aa24a8-11a1-41cb-e016-2ef76a446705"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.Size([1, 3, 3])"
            ]
          },
          "metadata": {},
          "execution_count": 82
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "TENSOR[0]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GMUoL2OFAqhn",
        "outputId": "4621ffbb-b7dc-44de-f112-f4636e167a0b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[1, 2, 3],\n",
              "        [3, 6, 9],\n",
              "        [2, 4, 5]])"
            ]
          },
          "metadata": {},
          "execution_count": 83
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "SOME_TENSOR = torch.tensor([[[[[[1,2,3],\n",
        "                                [3,4,5],\n",
        "                                [6,9,4]]]]]])"
      ],
      "metadata": {
        "id": "AphEpLO0AzNA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "SOME_TENSOR.ndim"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "o5nAplkkBb69",
        "outputId": "35d59801-fe4e-4637-c1dc-270796e01a9c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "6"
            ]
          },
          "metadata": {},
          "execution_count": 85
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "SOME_TENSOR.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ni0RlR-SBgt0",
        "outputId": "719f7533-79bb-4575-ccad-6ebc772b8db4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.Size([1, 1, 1, 1, 3, 3])"
            ]
          },
          "metadata": {},
          "execution_count": 86
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "AN_TENSOR = torch.tensor([[12,33,4],[2,3,4]])"
      ],
      "metadata": {
        "id": "A5IO6b08BmgV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "AN_TENSOR.ndim"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iwWkhq7FB-Mr",
        "outputId": "d8e95d48-3e9b-4c06-83c2-1f0f35ac89fb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {},
          "execution_count": 88
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Random Tensors\n",
        "\n",
        "Why random tensors?\n",
        "\n",
        "Random tensors are important beacause the way many neural network learn is what they start with tensors full of random numbers and then adjust those random numbers to better represent the data.\n",
        "\n",
        "`Start with random numbers -> look at data -> update random numbers -> look at data -> update random numbers`"
      ],
      "metadata": {
        "id": "ur3q-1e5CY1A"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### creating random tensor using PyTorch\n",
        "\n",
        "Link: https://pytorch.org/docs/stable/generated/torch.rand.html"
      ],
      "metadata": {
        "id": "5QgeGdjFDmC5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# create a random tensor of size (3,4)\n",
        "random_tensor = torch.rand(3,4)\n",
        "random_tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FAduRxrVCs4W",
        "outputId": "920515b4-fe91-416c-d72d-bb1f15f545da"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[0.2052, 0.3981, 0.0160, 0.2731],\n",
              "        [0.9250, 0.0606, 0.9168, 0.2466],\n",
              "        [0.7639, 0.6137, 0.6267, 0.5795]])"
            ]
          },
          "metadata": {},
          "execution_count": 89
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "random_tensor.ndim"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "020IwkkiDvMl",
        "outputId": "a79c5cf5-94f9-427f-dec5-da7f528609ef"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {},
          "execution_count": 90
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "random_tensor.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "w1OZ4nqBDykZ",
        "outputId": "5e6b97ab-94e7-46b7-b685-1af97ed0ade6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.Size([3, 4])"
            ]
          },
          "metadata": {},
          "execution_count": 91
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "# create a random tensor with similar shape to an image tensor\n",
        "random_image_size_tensor = torch.rand(size=(224, 224, 4)) # height, width, color channels (R, G, B)\n",
        "random_image_size_tensor.shape, random_image_size_tensor.ndim"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fjvmaxxvD0Wf",
        "outputId": "83058315-19a5-45ef-a3dd-bb5a2a5ea615"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(torch.Size([224, 224, 4]), 3)"
            ]
          },
          "metadata": {},
          "execution_count": 92
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "random_image_size_tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XuVfRdjJEbwv",
        "outputId": "6a9089b8-1b49-40b9-a958-fa3e88ee2fc6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[[5.2445e-02, 5.8635e-01, 3.8473e-01, 5.0250e-02],\n",
              "         [7.7300e-01, 9.8747e-01, 3.4640e-01, 2.9744e-01],\n",
              "         [1.9762e-02, 6.0307e-01, 6.0053e-01, 9.8027e-01],\n",
              "         ...,\n",
              "         [8.7832e-01, 3.1772e-01, 4.1542e-01, 5.4752e-02],\n",
              "         [1.9661e-01, 9.8406e-01, 6.3758e-01, 6.4827e-01],\n",
              "         [9.2873e-01, 9.7439e-01, 1.9271e-01, 9.5985e-01]],\n",
              "\n",
              "        [[8.4687e-01, 4.8546e-01, 8.7452e-01, 3.6045e-01],\n",
              "         [7.4077e-02, 1.6478e-01, 6.3043e-01, 7.2933e-01],\n",
              "         [7.2619e-01, 1.6769e-01, 5.4128e-01, 9.5612e-01],\n",
              "         ...,\n",
              "         [7.8419e-01, 8.8248e-02, 3.9485e-01, 8.7470e-01],\n",
              "         [6.8498e-04, 5.1420e-01, 3.0424e-01, 6.4107e-01],\n",
              "         [4.3747e-01, 7.3705e-01, 1.5898e-01, 9.4686e-01]],\n",
              "\n",
              "        [[9.9075e-01, 6.8644e-01, 5.9591e-01, 9.8516e-01],\n",
              "         [7.1053e-01, 2.4054e-01, 7.6130e-01, 9.8798e-01],\n",
              "         [3.3123e-02, 7.3869e-01, 6.5577e-01, 2.6603e-01],\n",
              "         ...,\n",
              "         [1.0206e-01, 6.0299e-01, 6.0617e-01, 4.4373e-01],\n",
              "         [5.0059e-01, 7.0556e-01, 7.1232e-01, 2.1604e-01],\n",
              "         [2.2852e-01, 8.0343e-01, 4.1188e-01, 6.4815e-01]],\n",
              "\n",
              "        ...,\n",
              "\n",
              "        [[4.9194e-01, 1.4949e-01, 9.8412e-01, 1.8217e-01],\n",
              "         [8.5622e-01, 1.4729e-01, 4.9621e-01, 1.7756e-01],\n",
              "         [6.5442e-01, 2.5024e-01, 4.8654e-01, 2.3273e-01],\n",
              "         ...,\n",
              "         [6.9608e-01, 4.4821e-01, 6.2830e-01, 7.6213e-01],\n",
              "         [4.6986e-01, 1.6769e-01, 6.8488e-01, 8.2976e-01],\n",
              "         [6.8462e-01, 2.6564e-01, 4.2999e-01, 3.6857e-01]],\n",
              "\n",
              "        [[7.3785e-01, 2.2713e-02, 6.8036e-01, 4.1760e-01],\n",
              "         [1.8128e-01, 4.3526e-01, 7.8746e-01, 4.2249e-01],\n",
              "         [2.9581e-02, 1.2391e-01, 9.9939e-01, 4.2137e-01],\n",
              "         ...,\n",
              "         [1.3463e-01, 8.1063e-01, 3.1124e-01, 5.3021e-01],\n",
              "         [8.0231e-01, 3.3319e-01, 7.5626e-01, 5.3691e-01],\n",
              "         [6.6304e-01, 2.2348e-01, 9.3875e-01, 2.5078e-01]],\n",
              "\n",
              "        [[9.2441e-01, 3.6428e-01, 1.6185e-01, 8.7728e-01],\n",
              "         [9.0186e-01, 7.6949e-01, 7.1127e-01, 2.4395e-01],\n",
              "         [8.8900e-01, 7.6608e-02, 5.6818e-01, 1.6162e-02],\n",
              "         ...,\n",
              "         [5.5828e-01, 8.5426e-01, 2.9225e-02, 1.1672e-01],\n",
              "         [4.3763e-01, 3.4828e-01, 5.9907e-01, 6.6379e-01],\n",
              "         [2.5561e-01, 3.3433e-01, 3.0638e-01, 2.1132e-01]]])"
            ]
          },
          "metadata": {},
          "execution_count": 93
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Exercise\n",
        "Creating tensor of any size for experimentation"
      ],
      "metadata": {
        "id": "OsxrQrBTEvXQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "myTensor = torch.rand(4,2)\n",
        "myTensor, myTensor,"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IPZQE1ohFLrO",
        "outputId": "87e4c27c-c515-4b69-c27a-43bedcb846b4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor([[0.9381, 0.3232],\n",
              "         [0.4607, 0.4363],\n",
              "         [0.7024, 0.9812],\n",
              "         [0.0574, 0.1926]]),\n",
              " tensor([[0.9381, 0.3232],\n",
              "         [0.4607, 0.4363],\n",
              "         [0.7024, 0.9812],\n",
              "         [0.0574, 0.1926]]))"
            ]
          },
          "metadata": {},
          "execution_count": 94
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "torch.rand(size=(3,4))"
      ],
      "metadata": {
        "id": "3drysA2wFUKt",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8c2ef387-fdd8-4139-b07d-23a1baa2bdae"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[0.9161, 0.6788, 0.6707, 0.0659],\n",
              "        [0.0045, 0.3775, 0.8660, 0.6580],\n",
              "        [0.3612, 0.9770, 0.2196, 0.8992]])"
            ]
          },
          "metadata": {},
          "execution_count": 95
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Zeros and Ones"
      ],
      "metadata": {
        "id": "1EsQ6HOXuDc5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# create a tensor of all zeros\n",
        "zero = torch.zeros(size=(3,4))\n",
        "zero"
      ],
      "metadata": {
        "id": "y-MO2y-vZB9h",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f21f0cf1-f116-4d7a-fd2b-4ed0707a218c"
      },
      "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": 96
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "random_tensor * zero"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YODzztpCuNYa",
        "outputId": "44f39dfe-4822-4fd3-e3b3-08f5ac781658"
      },
      "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": 97
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# create a tensor of all ones\n",
        "ones = torch.ones(size=(3,4))\n",
        "ones"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "R_4uGFbsuhrF",
        "outputId": "6b291ecb-72dc-4a73-cf90-91c4b8436242"
      },
      "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": 98
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "ones.dtype"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LyR_rEx5urJ4",
        "outputId": "6432f569-9f16-4da3-9a9b-1e2f493d53f3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.float32"
            ]
          },
          "metadata": {},
          "execution_count": 99
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "random_tensor.dtype"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WRX8Piahuud4",
        "outputId": "989515e4-03fe-4fec-aa83-fc29fb0a1716"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.float32"
            ]
          },
          "metadata": {},
          "execution_count": 100
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### creating a range of tensors and tensors-like"
      ],
      "metadata": {
        "id": "RIkQ4jZuu79y"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# use torch.range() and get deprecated message so use torch.arange()\n",
        "torch.range(0,10)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9DDD6brVuzW6",
        "outputId": "3d5247bb-ee2d-45a7-9d05-ce0123ac584f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-101-422f24684e88>:2: UserWarning: torch.range is deprecated and will be removed in a future release because its behavior is inconsistent with Python's range builtin. Instead, use torch.arange, which produces values in [start, end).\n",
            "  torch.range(0,10)\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])"
            ]
          },
          "metadata": {},
          "execution_count": 101
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# use torch.arange()\n",
        "one_to_ten = torch.arange(start=1, end=11, step=1)\n",
        "one_to_ten"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jlt10wHhvDtu",
        "outputId": "e991832d-9e75-4029-93c3-c2a395ccf49e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10])"
            ]
          },
          "metadata": {},
          "execution_count": 102
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# creating tensors like\n",
        "ten_zeros = torch.zeros_like(input=one_to_ten)"
      ],
      "metadata": {
        "id": "Ulk7jXYxvHx-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "ten_zeros"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "S1jrDMqDvzCL",
        "outputId": "de67517e-cc9c-4f0e-beff-61cc5096c2bd"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])"
            ]
          },
          "metadata": {},
          "execution_count": 104
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Tensor datatypes\n",
        "\n",
        "**Note:** Tensor datatypes is one of the 3 big errors you'll run into with PyTorch and Deep Learning:\n",
        "1. Tensors not right datatype\n",
        "2. Tensor not right shape\n",
        "3. Tensor not on the right device"
      ],
      "metadata": {
        "id": "wHnnYYQMwpIm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# float 32 tensor\n",
        "float_32_tensor = torch.tensor([3.6, 4.2, 6.9, 9.6],\n",
        "                               dtype=None,      # what datatype is tensor (e.g. float32, float 16)\n",
        "                               device=None,     # what device is your tensor on\n",
        "                               requires_grad=False) # whether or not to track gradients with this tensors operations\n"
      ],
      "metadata": {
        "id": "pKFtwuBjv13S"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "float_32_tensor.dtype"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "R74UJt0cwsxa",
        "outputId": "dba92478-11fc-4338-de6f-120be54cdbeb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.float32"
            ]
          },
          "metadata": {},
          "execution_count": 106
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "float_32_tensor.device"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0dt_OZnUw7uR",
        "outputId": "893a64f7-d4fd-4c36-983d-bf34fd55034b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "device(type='cpu')"
            ]
          },
          "metadata": {},
          "execution_count": 107
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "float_16_tensor = float_32_tensor.type(torch.float16)\n",
        "float_16_tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JBaX8HJ3yc5J",
        "outputId": "daf662cb-09b4-4036-f3f6-e0da24c760c6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([3.5996, 4.1992, 6.8984, 9.6016], dtype=torch.float16)"
            ]
          },
          "metadata": {},
          "execution_count": 108
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "ch8cnYslzaYF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "uOytvgj6zaVP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "some_tensor = float_16_tensor * float_32_tensor\n",
        "some_tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "P5JPrqqpzOim",
        "outputId": "edf023f8-adcd-49ff-fd95-e3694c22d3cd"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([12.9586, 17.6367, 47.5992, 92.1750])"
            ]
          },
          "metadata": {},
          "execution_count": 109
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "some_tensor.dtype, some_tensor.device, some_tensor.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qJbWo7uUzgoW",
        "outputId": "199083ee-8bcc-4ad8-b475-728710cf8c0d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(torch.float32, device(type='cpu'), torch.Size([4]))"
            ]
          },
          "metadata": {},
          "execution_count": 110
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "int_32_tensor = torch.tensor([6,9,4,2], dtype=torch.int32)\n",
        "int_32_tensor"
      ],
      "metadata": {
        "id": "BCPgL_gDzqVN",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "db70d960-9ee3-453d-e071-e2e209b175f7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([6, 9, 4, 2], dtype=torch.int32)"
            ]
          },
          "metadata": {},
          "execution_count": 111
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "res_tensor = float_32_tensor * int_32_tensor\n",
        "print(res_tensor)\n",
        "res_tensor.dtype,  res_tensor.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7meT70JWtt6x",
        "outputId": "e1b173aa-7b07-4b28-867b-0bdbac601a8f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([21.6000, 37.8000, 27.6000, 19.2000])\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(torch.float32, torch.Size([4]))"
            ]
          },
          "metadata": {},
          "execution_count": 112
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Getting information from Tensor (tensor attributes)\n",
        "\n",
        "1. Tensors not right datatype - to get data type from a tensor, we can use `tensor.dtype`\n",
        "2. Tensor not right shape - to get shape from a tensor, we can use `tensor.shape`\n",
        "\n",
        "3. Tensor not on the right device - to get device from a tensor, we can use `tensor.device`\n"
      ],
      "metadata": {
        "id": "eQoak8qzujYQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# create a tensor\n",
        "some_tensor  = torch.rand(3,4, device=\"cpu\", dtype=torch.float32)"
      ],
      "metadata": {
        "id": "cIW1NXuGt-nZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "some_tensor.size(), some_tensor.shape"
      ],
      "metadata": {
        "id": "UT6uzHXPvRbc",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7d716715-509d-43e5-d633-9f3dcd32ff17"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(torch.Size([3, 4]), torch.Size([3, 4]))"
            ]
          },
          "metadata": {},
          "execution_count": 114
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# find out some details about the tensor\n",
        "print(some_tensor)\n",
        "print(f\"Data type of tensor: {some_tensor.dtype}\")\n",
        "print(f\"Shape of tensor: {some_tensor.shape}\")\n",
        "print(f\"Device tensor is on: {some_tensor.device}\")"
      ],
      "metadata": {
        "id": "Xg9kMy5UuJfQ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ed963734-417f-4bef-eeea-ddd7f2031d71"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([[0.4330, 0.0421, 0.8349, 0.5157],\n",
            "        [0.7433, 0.9813, 0.7194, 0.8682],\n",
            "        [0.0212, 0.9260, 0.1632, 0.5780]])\n",
            "Data type of tensor: torch.float32\n",
            "Shape of tensor: torch.Size([3, 4])\n",
            "Device tensor is on: cpu\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "dpLPlfC7vMl8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Manipulating Tensors (**tensor operations**):\n",
        "\n",
        "Tensor operations includde:\n",
        "* Addition\n",
        "* Subtraction\n",
        "* Multiplication( element-wise)\n",
        "* Division\n",
        "* Matrix Multiplication"
      ],
      "metadata": {
        "id": "4QeBjZVNws0e"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "## create a tensor and add 10 to it\n",
        "tensor = torch.tensor([1,2,3])\n",
        "tensor + 10"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "f1lgKrNBwwua",
        "outputId": "ba2c95da-d71e-46af-f2dd-75902bc6d740"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([11, 12, 13])"
            ]
          },
          "metadata": {},
          "execution_count": 116
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "## multiply tensor by 10\n",
        "tensor * 10\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aIwdm6vUySM0",
        "outputId": "5a74d2da-9319-4028-8f1f-3b2b99e8f9bc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([10, 20, 30])"
            ]
          },
          "metadata": {},
          "execution_count": 117
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "## subtract 10\n",
        "tensor - 10"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SrUfAPF-ydVT",
        "outputId": "ebe98d8c-3911-49d7-c8fb-d142a4e42cf5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([-9, -8, -7])"
            ]
          },
          "metadata": {},
          "execution_count": 118
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "## try out PyTorch in-build functions\n",
        "torch.mul(tensor,10) # multiply by 10"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-Dr8W-YVy5Iy",
        "outputId": "96311234-6a61-4997-d5ed-75385826572e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([10, 20, 30])"
            ]
          },
          "metadata": {},
          "execution_count": 119
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "torch.add(tensor,2) # add 2 to tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tE510DiizCxx",
        "outputId": "af163684-bcc3-4a12-8ef2-ed4ca161bf73"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([3, 4, 5])"
            ]
          },
          "metadata": {},
          "execution_count": 120
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "torch.sub(tensor, 10) # subtract tensor from 10"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Fn14EH_6zLAt",
        "outputId": "94fc350c-39fc-4075-8e6b-af862ac66d96"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([-9, -8, -7])"
            ]
          },
          "metadata": {},
          "execution_count": 121
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tensor / 10"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "S2-YVk0tzP2w",
        "outputId": "a598b36c-82ce-48e2-cf7e-82e0811cab23"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([0.1000, 0.2000, 0.3000])"
            ]
          },
          "metadata": {},
          "execution_count": 122
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "lH85GbiRzTNh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Matrix multiplication\n",
        "\n",
        "Two main ways of performing multiplication in neural networks and deep learning:\n",
        "1. Element-wise multiplication\n",
        "2. Matrix multiplication / dot product (most common multiplication)\n",
        "\n",
        "\n",
        "\n",
        "There are two main rules that performing matrix multiplication needs to satisfy:\n",
        "1. The **inner dimensions** must match:\n",
        "* `(3,2) @ (3,2)` won't work\n",
        "* `(2,3) @ (3,2)` will work\n",
        "* `(3,2) @ (2,3)` will work\n",
        "* `(2,3) @ (2,3)` won't work\n",
        "\n",
        "\n",
        "2. The resulting matrix has the shape of the **outer dimensions**:\n",
        "* `(2,3) @ (3,2)` -> `(2,2)`\n",
        "* `(3,2) @ (2,3)` -> `(3,3)`"
      ],
      "metadata": {
        "id": "Vqm7Sx33zbwG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "torch.matmul(torch.rand(3,2), torch.rand(2,3))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HgSvhjd5281l",
        "outputId": "47632bba-e094-461d-94e5-c68deffa7638"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[0.2844, 0.2384, 0.2437],\n",
              "        [0.2813, 0.3066, 0.3380],\n",
              "        [0.8617, 0.7240, 0.7405]])"
            ]
          },
          "metadata": {},
          "execution_count": 123
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Element wise multiplication\n",
        "print(tensor, \"*\", tensor)\n",
        "print(f\"Equals: {tensor * tensor}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vvlwcS0aznf8",
        "outputId": "38f50360-e82c-4fa9-dced-9cea341fd8c8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([1, 2, 3]) * tensor([1, 2, 3])\n",
            "Equals: tensor([1, 4, 9])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# matrix multiplication\n",
        "torch.matmul(tensor,tensor)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wJ0p-5iv0Lsj",
        "outputId": "d3784009-64ef-4767-f419-b76dca24da6a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor(14)"
            ]
          },
          "metadata": {},
          "execution_count": 125
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LDz770CU05D3",
        "outputId": "16fcc877-1ac7-4bc7-d9da-b69f1d7fb50e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([1, 2, 3])"
            ]
          },
          "metadata": {},
          "execution_count": 126
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# matrix multiplication by hand\n",
        "1*1 + 2*2 + 3*3"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QJhIvlpU0cRv",
        "outputId": "eb1193f0-7589-4d34-faea-21138a0bc35a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "14"
            ]
          },
          "metadata": {},
          "execution_count": 127
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "%%time\n",
        "value = 0\n",
        "for i in range(len(tensor)):\n",
        "  value += tensor[i] * tensor[i]\n",
        "print(value)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aHaiDNDR1Cc7",
        "outputId": "15807c48-990c-4a88-8248-9fef8a50a83d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor(14)\n",
            "CPU times: user 1.87 ms, sys: 0 ns, total: 1.87 ms\n",
            "Wall time: 3.19 ms\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "%%time\n",
        "torch.matmul(tensor, tensor)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "D5m9zNNV1Q5y",
        "outputId": "ad7dc0ae-ac8e-4d2c-febb-be2c6bc8cd26"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "CPU times: user 101 µs, sys: 0 ns, total: 101 µs\n",
            "Wall time: 107 µs\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor(14)"
            ]
          },
          "metadata": {},
          "execution_count": 129
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### One of the most common error in deep learning ar"
      ],
      "metadata": {
        "id": "uXQPgT2a2KdO"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "https://matrixmultiplication.xyz"
      ],
      "metadata": {
        "id": "nSpkg0QW4Bh6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#  Shpes for matrix multiplication\n",
        "tensor_A = torch.tensor([[1, 2],\n",
        "                         [3, 4],\n",
        "                         [5, 6]])\n",
        "tensor_B = torch.tensor([[7, 10],\n",
        "                         [8, 11],\n",
        "                         [9, 12]])\n",
        "# torch.mm(tensor_A, tensor_B)     # torch.mm is the same as torch.matmul (it's an alias for torch.matmul)\n",
        "torch.matmul(tensor_A, tensor_B.T)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Gzd9bmYW1oIY",
        "outputId": "5517d4b7-a92f-48b4-c5f5-c97c9caa8b00"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[ 27,  30,  33],\n",
              "        [ 61,  68,  75],\n",
              "        [ 95, 106, 117]])"
            ]
          },
          "metadata": {},
          "execution_count": 132
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tensor_A.shape, tensor_B.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "c6Jn0mck41uD",
        "outputId": "ed50393b-9044-4536-e368-5c3030e321e3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(torch.Size([3, 2]), torch.Size([3, 2]))"
            ]
          },
          "metadata": {},
          "execution_count": 133
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# to fix our tensor shape issues, we can manipulate the shape of one of our tensor using a **transpose**.\n",
        "\n",
        "A **transpose** switches the axes or dimensions of a given tensor."
      ],
      "metadata": {
        "id": "8HvXuE1A5QEa"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tensor_B, tensor_B.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_qXNYYn3488S",
        "outputId": "e122fce0-692d-4e7f-d4c3-e9ed7ba12ce8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor([[ 7, 10],\n",
              "         [ 8, 11],\n",
              "         [ 9, 12]]),\n",
              " torch.Size([3, 2]))"
            ]
          },
          "metadata": {},
          "execution_count": 134
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tensor_B.T, tensor_B.T.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "liylq04Q5IJS",
        "outputId": "a6425c57-4008-4812-c073-841fb0162073"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor([[ 7,  8,  9],\n",
              "         [10, 11, 12]]),\n",
              " torch.Size([2, 3]))"
            ]
          },
          "metadata": {},
          "execution_count": 135
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "## The matrix multiplication operation works when tensor_B is transposed\n",
        "print(f\"Original shape : tensor_A = {tensor_A.shape}, tensor_B = {tensor_B.shape}\\n\")\n",
        "print(f\"New shape : tensor_A = {tensor_A.shape} (same shape as above), tensor_B = {tensor_B.T.shape}\\n\")\n",
        "print(f\"Multiplying: {tensor_A.shape} @ {tensor_B.T.shape} <- inner dimensions must match\\n\")\n",
        "print(\"Output:\\n\")\n",
        "output = torch.matmul(tensor_A, tensor_B.T)\n",
        "print(output)\n",
        "\n",
        "print(f\"\\nOutput shape: {output.shape}\\n\")\n",
        "\n",
        "\n",
        "torch.mm(tensor_A, tensor_B.T)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pNJl2set5eyF",
        "outputId": "1b62467d-37a4-4344-ab4c-b0f078029f01"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Original shape : tensor_A = torch.Size([3, 2]), tensor_B = torch.Size([3, 2])\n",
            "\n",
            "New shape : tensor_A = torch.Size([3, 2]) (same shape as above), tensor_B = torch.Size([2, 3])\n",
            "\n",
            "Multiplying: torch.Size([3, 2]) @ torch.Size([2, 3]) <- inner dimensions must match\n",
            "\n",
            "Output:\n",
            "\n",
            "tensor([[ 27,  30,  33],\n",
            "        [ 61,  68,  75],\n",
            "        [ 95, 106, 117]])\n",
            "\n",
            "Output shape: torch.Size([3, 3])\n",
            "\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[ 27,  30,  33],\n",
              "        [ 61,  68,  75],\n",
              "        [ 95, 106, 117]])"
            ]
          },
          "metadata": {},
          "execution_count": 136
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "E7pJLlgu56Kj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Tensor aggregation\n",
        "### finding the min, max, mean, sum, etc."
      ],
      "metadata": {
        "id": "F3zyMpi59fbc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch"
      ],
      "metadata": {
        "id": "XiZdD-z9yeo1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# create a tensor\n",
        "x = torch.arange(0,100,10, dtype=torch.float32)\n",
        "x"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FwfUUt-19m4V",
        "outputId": "fef5ac9c-04f7-471f-c2d5-2a59d30494ee"
      },
      "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": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# find the min\n",
        "torch.min(x), x.min()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "z5QjcPDl9xFy",
        "outputId": "66f7365b-5fa2-4deb-fa15-7023abf02b4f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor(0.), tensor(0.))"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# find the max\n",
        "torch.max(x), x.max()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "62DABbSD90t7",
        "outputId": "6df901f7-124d-4604-c900-a9bf24f25cfe"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor(90.), tensor(90.))"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# find the mean : NOTE: the `torch.mean()` function requires a tensor of float32 data type to work\n",
        "torch.mean(x), x.mean()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SLfbhYPS955b",
        "outputId": "da68d843-150d-4d28-e2d6-7167c69ba4e5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor(45.), tensor(45.))"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# find the sum\n",
        "torch.sum(x), x.sum()"
      ],
      "metadata": {
        "id": "WQ2_FIGI-ADD",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d3880357-cd2a-4b5d-bcc1-37749df46bba"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor(450.), tensor(450.))"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## finding the positional min and max"
      ],
      "metadata": {
        "id": "MXfoF_ylwFTf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x"
      ],
      "metadata": {
        "id": "33nAV7prBN-t",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "24aa2943-eb12-4625-bad9-181f46820d0e"
      },
      "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": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "## find the postion in tensor that has the minimum value with argmin() -> returns the index position of target tensor where the minimu value occures\n",
        "x.argmin()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KTs2P618whom",
        "outputId": "6f66b3fc-676e-4c21-9e78-91eadf96e1e8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor(0)"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x[0]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "C3E8Lp7Wwwq3",
        "outputId": "3db71978-bf1b-4697-9de5-e099b8f5c071"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor(0.)"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "## find the position in tensor that has maximu  value with argmax()\n",
        "x.argmax()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "A0UF1yT-w0aR",
        "outputId": "b277dd34-2a4a-4ffb-d521-475dcdb9e794"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor(9)"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x[9]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Myoelb5qw7q-",
        "outputId": "bb56b87a-2972-41b0-e126-a4cf9e2163fa"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor(90.)"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wmBdLSyvw9n-",
        "outputId": "c3bf166f-cdcf-4afb-f612-b497a5bb8e52"
      },
      "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": 13
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Reshaping, stacking, squeezing and unsqueezing tensors\n",
        "\n",
        "* Reshaping - reshapeds an input tensor to a defined shape\n",
        "* View - Returns a view of an input tensor of certain shape but keep tha same memory as the original tensor\n",
        "* Stacking - combine the multple  tensors on top of each other (vstack) or side by side (hstack)\n",
        "* Squeeze - removes all `1` dimensions from a tensor\n",
        "* Unsqueeze - adds a `1` dimension to a target tensor\n",
        "* Permute - returns a view of the input with dimension permuted(swapped) in a certain way\n",
        "\n"
      ],
      "metadata": {
        "id": "BUN48PIixSOJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "## creating a tensor\n",
        "import torch\n",
        "x = torch.arange(1., 10.)\n",
        "x, x.shape,"
      ],
      "metadata": {
        "id": "mcr7B65BxEDA",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "bf0022db-2eca-4a0d-9150-9ea22e1b6391"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor([1., 2., 3., 4., 5., 6., 7., 8., 9.]), torch.Size([9]))"
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# add an extra dimension\n",
        "x_reshaped = x.reshape((1,9))\n",
        "x_reshaped, x_reshaped.shape"
      ],
      "metadata": {
        "id": "IhP-OTT2ytOj",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "254c3643-2125-4cfd-ad19-f62b69222011"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor([[1., 2., 3., 4., 5., 6., 7., 8., 9.]]), torch.Size([1, 9]))"
            ]
          },
          "metadata": {},
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# change the view\n",
        "z = x.view(1,9)\n",
        "z, z.shape"
      ],
      "metadata": {
        "id": "XqtlOlssA6FX",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4470ac5a-ef01-4338-b07d-c6425254a100"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor([[1., 2., 3., 4., 5., 6., 7., 8., 9.]]), torch.Size([1, 9]))"
            ]
          },
          "metadata": {},
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# changing z changes x (because a view of a tensor shares the same memory as the orignal input)\n",
        "z[:, 0] = 5\n",
        "z, x"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "u2_vSHkwwI9q",
        "outputId": "3decffa2-04d5-4db9-d321-90b625f04909"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor([[5., 2., 3., 4., 5., 6., 7., 8., 9.]]),\n",
              " tensor([5., 2., 3., 4., 5., 6., 7., 8., 9.]))"
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Stack tensor on top of each other\n",
        "x_stacked = torch.stack([x, x, x, x], dim=0)\n",
        "x_stacked"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hWbWOzv8xo8v",
        "outputId": "22acdd71-8e73-4095-c251-88a7db3c828f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[5., 2., 3., 4., 5., 6., 7., 8., 9.],\n",
              "        [5., 2., 3., 4., 5., 6., 7., 8., 9.],\n",
              "        [5., 2., 3., 4., 5., 6., 7., 8., 9.],\n",
              "        [5., 2., 3., 4., 5., 6., 7., 8., 9.]])"
            ]
          },
          "metadata": {},
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x.ndim"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UD_kPWMIya5h",
        "outputId": "b9e5b802-5721-4f59-b0d1-05042207bd89"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "# Stack tensor on top of each other\n",
        "x_stacked = torch.stack([x, x, x, x], dim=1)\n",
        "x_stacked"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "33EHhfAyx6ku",
        "outputId": "5576a571-3784-4963-d554-60b196225e7d"
      },
      "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": 20
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Stack tensor on top of each other\n",
        "# x_stacked = torch.stack([x, x, x, x], dim=)   # this produces error `IndexError: Dimension out of range (expected to be in range of [-2, 1], but got 2)`\n",
        "# x_stacked"
      ],
      "metadata": {
        "id": "3UP2EjghyNJB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "e0TkOlAhyOcb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "O46umfZfyqHp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# torch.squeeze() - removes all the single dimensions from a target *tensor*\n",
        "print(f\"Previous tensor : {x_reshaped}\")\n",
        "print(f\"Previous shape: {x_reshaped.shape}\")\n",
        "\n",
        "# remove extra dimensions from x_reshaped\n",
        "x_squeezed = x_reshaped.squeeze()\n",
        "print(f\"\\nNew tensor: {x_squeezed}\")\n",
        "print(f\"New shape: {x_squeezed.shape}\")\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Q2giVN3Ayt2V",
        "outputId": "794acc48-6d64-4c19-a02a-96e1e35e4a2e"
      },
      "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": [
        "# torch.unsqueeze() - adds a single dimension to target tensor at a specific dimension\n",
        "print(f\"Previous targed: {x_squeezed}\")\n",
        "print(f\"Previous shape: {x_squeezed.shape}\")\n",
        "\n",
        "# add an extra dimension with unsqueeze\n",
        "x_unsqueezed = x_squeezed.unsqueeze(dim=0)\n",
        "print(f\"\\nNew Squeezed Tensor : {x_unsqueezed}\")\n",
        "print(f\"New Squeezed shape: {x_unsqueezed.shape}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8hz8JgEPy9Pg",
        "outputId": "7cbc2096-8dba-44d9-94d7-13d181385779"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Previous targed: tensor([5., 2., 3., 4., 5., 6., 7., 8., 9.])\n",
            "Previous shape: torch.Size([9])\n",
            "\n",
            "New Squeezed Tensor : tensor([[5., 2., 3., 4., 5., 6., 7., 8., 9.]])\n",
            "New Squeezed shape: torch.Size([1, 9])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# torch.permute() -- rearranges the dimensions of a target tensor in a specified order\n",
        "x_original = torch.rand(size=(224, 224, 3)) # [height, width, color_channels]\n",
        "\n",
        "# permute the orignal tensor to rearrage the axis (or dim) or order\n",
        "x_permuted = torch.permute(x_original,[2, 0, 1])   # shifts the axis 0->1, 1->2 and 2->0\n",
        "# x_permuted = x_original.permute(2, 0, 1)   # shifts the axis 0->1, 1->2 and 2->0\n",
        "print(f\"Previous shape: {x_original.shape}\")\n",
        "print(f\"New shape: {x_permuted.shape}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TEcb3Ho0y-cT",
        "outputId": "9b487d1a-e188-4f3b-9f47-46c62a69179a"
      },
      "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": "code",
      "source": [
        "x_new = x_original.permute([2,0,1])\n",
        "print(f\"x_original shape : {x_original.shape}\")\n",
        "print(f\"x_new shape : {x_new.shape}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bI8gHeYy9ZmN",
        "outputId": "39646ec5-d279-4987-bc8e-e89c8d35dee7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "x_original shape : torch.Size([224, 224, 3])\n",
            "x_new shape : torch.Size([3, 224, 224])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x_original[:, :, :]"
      ],
      "metadata": {
        "id": "_X-eA_fs_DdJ",
        "outputId": "84ffc7fa-a708-4881-e145-578066ff5e6c",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[[0.2920, 0.7048, 0.4679],\n",
              "         [0.5033, 0.1183, 0.0698],\n",
              "         [0.0158, 0.0870, 0.0370],\n",
              "         ...,\n",
              "         [0.3089, 0.2342, 0.3398],\n",
              "         [0.9800, 0.1234, 0.8071],\n",
              "         [0.1167, 0.7539, 0.2283]],\n",
              "\n",
              "        [[0.2743, 0.4649, 0.3584],\n",
              "         [0.9758, 0.0145, 0.8955],\n",
              "         [0.1447, 0.9751, 0.2876],\n",
              "         ...,\n",
              "         [0.2076, 0.5101, 0.6858],\n",
              "         [0.3535, 0.8822, 0.5391],\n",
              "         [0.5830, 0.1542, 0.0750]],\n",
              "\n",
              "        [[0.0741, 0.7101, 0.5454],\n",
              "         [0.3470, 0.4038, 0.6601],\n",
              "         [0.4927, 0.2346, 0.6352],\n",
              "         ...,\n",
              "         [0.9848, 0.3812, 0.4026],\n",
              "         [0.7813, 0.6542, 0.8385],\n",
              "         [0.0880, 0.6406, 0.8749]],\n",
              "\n",
              "        ...,\n",
              "\n",
              "        [[0.9886, 0.9110, 0.4350],\n",
              "         [0.3460, 0.9001, 0.4590],\n",
              "         [0.6042, 0.1292, 0.2238],\n",
              "         ...,\n",
              "         [0.0023, 0.4511, 0.6085],\n",
              "         [0.4647, 0.2605, 0.1605],\n",
              "         [0.8607, 0.7394, 0.2890]],\n",
              "\n",
              "        [[0.5085, 0.2119, 0.4589],\n",
              "         [0.7806, 0.9071, 0.1030],\n",
              "         [0.5308, 0.7420, 0.9016],\n",
              "         ...,\n",
              "         [0.7793, 0.4762, 0.8721],\n",
              "         [0.8763, 0.9477, 0.7602],\n",
              "         [0.0884, 0.1980, 0.1546]],\n",
              "\n",
              "        [[0.1243, 0.8666, 0.6254],\n",
              "         [0.8251, 0.8302, 0.6202],\n",
              "         [0.3676, 0.1675, 0.9249],\n",
              "         ...,\n",
              "         [0.5288, 0.6010, 0.1094],\n",
              "         [0.0937, 0.6067, 0.2209],\n",
              "         [0.9710, 0.4924, 0.8664]]])"
            ]
          },
          "metadata": {},
          "execution_count": 71
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x_original[:,:,0]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "g-90w6xkzu9_",
        "outputId": "1a9b4e77-1e40-4fbd-b38f-747860f4306a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[0.4313, 0.8700, 0.6883,  ..., 0.7593, 0.3433, 0.6542],\n",
              "        [0.0771, 0.1252, 0.0567,  ..., 0.1975, 0.2904, 0.2766],\n",
              "        [0.7207, 0.7048, 0.1708,  ..., 0.5379, 0.2220, 0.0263],\n",
              "        ...,\n",
              "        [0.8522, 0.6503, 0.2598,  ..., 0.2212, 0.6889, 0.2867],\n",
              "        [0.2451, 0.2722, 0.3941,  ..., 0.7732, 0.3720, 0.1873],\n",
              "        [0.6290, 0.5249, 0.8767,  ..., 0.6220, 0.5426, 0.2301]])"
            ]
          },
          "metadata": {},
          "execution_count": 43
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x_original[:,:,:]"
      ],
      "metadata": {
        "id": "Fk8LSLTGzAyd",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ff99e3f4-d3e4-406c-cfe5-8c5dad17e571"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[[0.4313, 0.8400, 0.2239],\n",
              "         [0.8700, 0.6104, 0.9950],\n",
              "         [0.6883, 0.6537, 0.3383],\n",
              "         ...,\n",
              "         [0.7593, 0.5176, 0.3601],\n",
              "         [0.3433, 0.9407, 0.5758],\n",
              "         [0.6542, 0.6973, 0.8342]],\n",
              "\n",
              "        [[0.0771, 0.6215, 0.3664],\n",
              "         [0.1252, 0.6305, 0.4735],\n",
              "         [0.0567, 0.7638, 0.5320],\n",
              "         ...,\n",
              "         [0.1975, 0.2701, 0.7154],\n",
              "         [0.2904, 0.8196, 0.4515],\n",
              "         [0.2766, 0.2389, 0.2149]],\n",
              "\n",
              "        [[0.7207, 0.9200, 0.7860],\n",
              "         [0.7048, 0.5379, 0.0433],\n",
              "         [0.1708, 0.4409, 0.5095],\n",
              "         ...,\n",
              "         [0.5379, 0.5430, 0.2342],\n",
              "         [0.2220, 0.4058, 0.3683],\n",
              "         [0.0263, 0.3461, 0.9233]],\n",
              "\n",
              "        ...,\n",
              "\n",
              "        [[0.8522, 0.7089, 0.1462],\n",
              "         [0.6503, 0.3053, 0.9227],\n",
              "         [0.2598, 0.6087, 0.4292],\n",
              "         ...,\n",
              "         [0.2212, 0.8408, 0.8549],\n",
              "         [0.6889, 0.3347, 0.3885],\n",
              "         [0.2867, 0.3506, 0.0915]],\n",
              "\n",
              "        [[0.2451, 0.1347, 0.2393],\n",
              "         [0.2722, 0.7000, 0.2072],\n",
              "         [0.3941, 0.6506, 0.4948],\n",
              "         ...,\n",
              "         [0.7732, 0.7898, 0.7814],\n",
              "         [0.3720, 0.2610, 0.8466],\n",
              "         [0.1873, 0.9690, 0.4441]],\n",
              "\n",
              "        [[0.6290, 0.0767, 0.4740],\n",
              "         [0.5249, 0.7403, 0.8120],\n",
              "         [0.8767, 0.7837, 0.0249],\n",
              "         ...,\n",
              "         [0.6220, 0.1558, 0.0343],\n",
              "         [0.5426, 0.1114, 0.2047],\n",
              "         [0.2301, 0.8281, 0.7844]]])"
            ]
          },
          "metadata": {},
          "execution_count": 41
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x_permuted[0, 0, 0] = 3\n",
        "x_original[0, 0, 0], x_permuted[0, 0, 0]\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qK7crxxSzG0x",
        "outputId": "b08f71d9-82aa-473d-b968-20bb4605357b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor(3.), tensor(3.))"
            ]
          },
          "metadata": {},
          "execution_count": 72
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# some = torch.randn(2,3,5)\n",
        "# some.size(), some"
      ],
      "metadata": {
        "id": "ovoUW3OJzsSd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# some_permuted =torch.permute(some, (2, 0, 1))\n",
        "# some_permuted.size(), some_permuted"
      ],
      "metadata": {
        "id": "ewewwV0j3Skh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "gau_T-hd3uvB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Indexing (selectiin data from tensors)\n",
        "\n",
        "Indexing with PyTorch is similar to index with NumPy."
      ],
      "metadata": {
        "id": "BIZuHfEz9XAC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# creating a tensor\n",
        "import torch\n",
        "x = torch.arange(1, 10).reshape(1, 3, 3)\n",
        "x, x.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iReLpSHP9e5T",
        "outputId": "f835a31f-9007-43d0-9b9e-3f031c7517c9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor([[[1, 2, 3],\n",
              "          [4, 5, 6],\n",
              "          [7, 8, 9]]]),\n",
              " torch.Size([1, 3, 3]))"
            ]
          },
          "metadata": {},
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Let's  index on our new tensor\n",
        "x[0]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pzqMILWi9pMh",
        "outputId": "8c85e873-1896-4e2b-9b7b-d20b52d544c7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[1, 2, 3],\n",
              "        [4, 5, 6],\n",
              "        [7, 8, 9]])"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Let's index on the middle bracket\n",
        "x[0][0], x[0, 0]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zrrfVA0zE_ux",
        "outputId": "b3c09ff1-5227-412d-b8c8-a8256468a68c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor([1, 2, 3]), tensor([1, 2, 3]))"
            ]
          },
          "metadata": {},
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# let's index on the most inner bracket\n",
        "x[0][1][1], x[0, 1, 1]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hH0CAB00FG6Z",
        "outputId": "a935aaf3-31dc-4beb-cc6a-fcd4d83459e0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor(5), tensor(5))"
            ]
          },
          "metadata": {},
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Challege to get number : 9\n",
        "x[0][2][2], x[0, 2, 2]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ENBSpFChFTPB",
        "outputId": "025f80cf-7137-4220-a53e-1bb4b7f71daa"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor(9), tensor(9))"
            ]
          },
          "metadata": {},
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# \":\" can also be used to select the target dimension\n",
        "x[:, 1]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lc2nwqSZFwhD",
        "outputId": "19fc81ae-a0a1-4507-ed6b-3b3fd1eabdbb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[4, 5, 6]])"
            ]
          },
          "metadata": {},
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# get all the values of 0th and 1st dimensions but only index 1 of 2nd dimension\n",
        "x[:, :, 1]"
      ],
      "metadata": {
        "id": "OG8CJWNMF_O_",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4c37d5e4-f8c5-4997-ee7f-bafc27279d7b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[2, 5, 8]])"
            ]
          },
          "metadata": {},
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# get all values of the 0 dimension but only the 1 index value of 1st and 2nd dimension\n",
        "x[:, 1, 1]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "z70EtrYBLPSi",
        "outputId": "292b6a9d-ae1b-49ee-c0bc-0a26a3f0fe7f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([5])"
            ]
          },
          "metadata": {},
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# get index 0 of 0th and 1st dimension and all values of 2nd dimension\n",
        "x[0, 0, :]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qsi6I33JLcHE",
        "outputId": "20013b28-c320-416b-9f50-f805310dcaf5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([1, 2, 3])"
            ]
          },
          "metadata": {},
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# index on x to return 9\n",
        "x[0,2,2], x\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eUy_Uz5nLtQl",
        "outputId": "c0fc182f-a1a8-453f-e6f2-611a194bd74f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor(9),\n",
              " tensor([[[1, 2, 3],\n",
              "          [4, 5, 6],\n",
              "          [7, 8, 9]]]))"
            ]
          },
          "metadata": {},
          "execution_count": 30
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# index on x to return 3, 6, 9\n",
        "\n",
        "x[:, :, 2]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "S1vUyLFSL7SR",
        "outputId": "1904e131-c778-4fab-fefb-3487f5df5c51"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[3, 6, 9]])"
            ]
          },
          "metadata": {},
          "execution_count": 31
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n"
      ],
      "metadata": {
        "id": "KPWkTkyJMLm_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## PyTorch tensors and NumPy\n",
        "\n",
        "Numpy is a popular scientific Python numberical computing library.\n",
        "\n",
        "And because of this, PyTorch has functionality to interact with it.\n",
        "\n",
        "* Data in NumPy, want in PyTorch tension -> `torch.from_numpy(ndarray)`\n",
        "* PyTorch tensor to Numpy data format -> `torch.Tensor.numpy()`"
      ],
      "metadata": {
        "id": "F_OgoL9PMbyM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# NumPy array to tensor\n",
        "import torch\n",
        "import numpy as np\n",
        "\n",
        "array = np.arange(1.0, 9.0)\n",
        "tensor = torch.from_numpy(array).type(torch.float32)      # by default it returns the torch datatype with `torch.float64`\n",
        "              # WARNING: when converting from numpy to pytorch, pytorch reflects numpy's default of float64, unless specifies\n",
        "array, tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "68Qr4kJBM7sW",
        "outputId": "7b403b7a-2219-4a30-e3e4-c1ea48d4828c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(array([1., 2., 3., 4., 5., 6., 7., 8.]),\n",
              " tensor([1., 2., 3., 4., 5., 6., 7., 8.]))"
            ]
          },
          "metadata": {},
          "execution_count": 1
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "array.dtype, tensor.dtype"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HBxdRBsxNJOc",
        "outputId": "a77d7fbb-bf47-49c9-b943-82539ba14040"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(dtype('float64'), torch.float32)"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "## Change the value of array, what will this do to `tensor`?\n",
        "array = array + 1\n",
        "array, tensor"
      ],
      "metadata": {
        "id": "6LQiKwm7NkmP",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "81858bea-0b7c-4eec-a3a3-0ab1b29c729f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(array([2., 3., 4., 5., 6., 7., 8., 9.]),\n",
              " tensor([1., 2., 3., 4., 5., 6., 7., 8.]))"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# tensor to NumPy array\n",
        "tensor = torch.ones(7)\n",
        "numpy_tensor = tensor.numpy()\n",
        "tensor, numpy_tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sau_-KlCetiT",
        "outputId": "d146d4ad-5f69-44a4-d01f-15b5f0a40824"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor([1., 1., 1., 1., 1., 1., 1.]),\n",
              " array([1., 1., 1., 1., 1., 1., 1.], dtype=float32))"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "numpy_tensor.dtype"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wZmOXIbEfD0N",
        "outputId": "799ea248-0767-4a13-b860-9811c63b669a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "dtype('float32')"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# change the tensor, what happes to `numpy_tensor`?\n",
        "tensor = tensor + 1\n",
        "tensor, numpy_tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XgQ3UB2wfK5N",
        "outputId": "c97dda7d-7ffd-4391-9cc3-8468f843f407"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor([2., 2., 2., 2., 2., 2., 2.]),\n",
              " array([1., 1., 1., 1., 1., 1., 1.], dtype=float32))"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Reproducibility (trying to take random out of random)\n",
        "\n",
        "in short how a neural network learns:\n",
        "`start with random number -> tensor operatiosn -> update random numbers to try and make them better representation of the data -> again -> again -> again....\n",
        "\n",
        "To reduce the randomnes in neural networks and PyTorch comes the concept of a **random seed**.\n",
        "\n",
        "Essentially what the random seed does is \"flavour\" the randomness.\n"
      ],
      "metadata": {
        "id": "IGvEtp1ihV4C"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "torch.rand(3,3)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VC9Oh5EPfZs8",
        "outputId": "9b318e54-46a6-4804-9f8c-379ca0f1d4da"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[0.2376, 0.7872, 0.7454],\n",
              "        [0.6929, 0.3211, 0.0985],\n",
              "        [0.0860, 0.9241, 0.7269]])"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "\n",
        "## create two random tensors\n",
        "random_tensor_A = torch.rand(3,4)\n",
        "random_tensor_B = torch.rand(3,4)\n",
        "\n",
        "print(random_tensor_A)\n",
        "print(random_tensor_B)\n",
        "print(random_tensor_A == random_tensor_B)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rnM13AcThqqw",
        "outputId": "4719a865-93ad-43da-e339-be9610612dda"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([[0.4247, 0.1353, 0.2923, 0.0580],\n",
            "        [0.4460, 0.5968, 0.2196, 0.2144],\n",
            "        [0.6006, 0.7958, 0.5704, 0.6043]])\n",
            "tensor([[0.9804, 0.2451, 0.6487, 0.6945],\n",
            "        [0.0930, 0.1670, 0.1633, 0.2685],\n",
            "        [0.1025, 0.8143, 0.9819, 0.7213]])\n",
            "tensor([[False, False, False, False],\n",
            "        [False, False, False, False],\n",
            "        [False, False, False, False]])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "## let's make some random but reproducible tensors\n",
        "\n",
        "import torch\n",
        "\n",
        "# set the random seed\n",
        "RANDOM_SEED = 42\n",
        "torch.manual_seed(RANDOM_SEED)\n",
        "random_tensor_C = torch.rand(3,4)\n",
        "\n",
        "torch.manual_seed(RANDOM_SEED)\n",
        "random_tensor_D = torch.rand(3,4)\n",
        "\n",
        "print(random_tensor_C)\n",
        "print(random_tensor_D)\n",
        "print(random_tensor_C == random_tensor_D)\n",
        "\n",
        "\n",
        "torch.manual_seed(RANDOM_SEED)\n",
        "random_tensor_E = torch.rand(3,4)\n",
        "\n",
        "print(random_tensor_E)\n",
        "print(random_tensor_C == random_tensor_E)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PKP3hDoxij5K",
        "outputId": "32143283-ee9c-478f-8e19-1644c1133f35"
      },
      "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",
            "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": [
        "##  Resources for Reproducibility:\n",
        "https://pytorch.org/docs/stable/notes/randomness.html"
      ],
      "metadata": {
        "id": "663ThDGgkKab"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "wpS0p0IKjZt1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Running tensors and PyTorch objects on the GPUs (making faster computations )\n",
        "\n",
        "\n",
        "GPUs = faster computation on numbers because of CUDA + NVIDIA + PyTorch working\n",
        "**bold text**"
      ],
      "metadata": {
        "id": "iyqkDWx5khyW"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "### 1. *getting* the GPU\n",
        "\n",
        "- use colab\n",
        "- use your own GPU\n",
        "- use cloud computing - GCP, AWS, Azure, - rent the computers on cloud and access them\n"
      ],
      "metadata": {
        "id": "7jnm0VIWk7xM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!nvidia-smi"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rA1WXA6NkoQE",
        "outputId": "e4b396bc-1982-4056-cc36-c2628e4300cb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Wed Dec 13 14:30:28 2023       \n",
            "+-----------------------------------------------------------------------------+\n",
            "| NVIDIA-SMI 525.105.17   Driver Version: 525.105.17   CUDA Version: 12.0     |\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  Tesla T4            Off  | 00000000:00:04.0 Off |                    0 |\n",
            "| N/A   49C    P8     9W /  70W |      0MiB / 15360MiB |      0%      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",
            "|  No running processes found                                                 |\n",
            "+-----------------------------------------------------------------------------+\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "### 2. Check for GPU access with PyTorch\n",
        "\n",
        "*italicized text*"
      ],
      "metadata": {
        "id": "jQNQUFdIlx3t"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# checkt for the GPU access with PyTorch\n",
        "import torch\n",
        "torch.cuda.is_available()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2f_jNjGZk5rE",
        "outputId": "ba4a19f5-1a15-4953-ea3c-4fd3a26ee7a6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "For PyTorch since it's capable of running compute on the GPU or CPU, it's best practice to setup device agnostic code:\n",
        "https://pytorch.org/docs/stable/notes/cuda.html#device-agnostic-code\n",
        "e.g. run on GPU if available, else default to CPU"
      ],
      "metadata": {
        "id": "zjjD9c3lnEhO"
      }
    },
    {
      "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": 36
        },
        "id": "6Ii-5hpdmEHv",
        "outputId": "6a55daa3-692b-4b1c-a828-ab3e905dba1c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'cuda'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "## Cound the number of devices\n",
        "torch.cuda.device_count()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "45HNMEkTmUY4",
        "outputId": "f6192230-fca7-458f-daff-846b0e8890fb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "3. putting tensors (and models ) on the GPU\n",
        "\n",
        "The reason we want our tensors/models on the GPU is because using a GPU a results in faster computations."
      ],
      "metadata": {
        "id": "FtSoO9RUnP5m"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "# create a tensor (default on the CPU)\n",
        "tensor = torch.tensor([1,2,3], device=\"cpu\")\n",
        "\n",
        "# tensor not on GPU\n",
        "print(tensor, tensor.device)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1ncmOtasmbe4",
        "outputId": "72d80cbd-ed3f-4b37-8551-6d42bd078210"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([1, 2, 3]) cpu\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RYNywskunwa5",
        "outputId": "276869d3-0be8-466c-a05f-aa5b44812fea"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([1, 2, 3])"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# move the tensor to GPU (if available)\n",
        "\n",
        "tensor_on_gpu  = tensor.to(device)\n",
        "tensor_on_gpu"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LVgtYvQYyV32",
        "outputId": "6380b364-c85a-4a12-cff5-38650d95344f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([1, 2, 3], device='cuda:0')"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 4. Moving tensors back to the CPU"
      ],
      "metadata": {
        "id": "uwDgsdxfzLg2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# If tensor is on GPU, can't transform it to NumPy\n",
        "\n",
        "tensor_on_gpu.numpy()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 236
        },
        "id": "Na87YNB5ykQZ",
        "outputId": "6871703a-4048-4f2a-d0a1-c63eb3793067"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-10-05364da70442>\u001b[0m in \u001b[0;36m<cell line: 3>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# If tensor is on GPU, can't transform it to NumPy\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mtensor_on_gpu\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnumpy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: can't convert cuda:0 device type tensor to numpy. Use Tensor.cpu() to copy the tensor to host memory first."
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# to fix the GPU tensor with NumPy issue, we can first set it to the CPU\n",
        "tensor_back_on_cpu = tensor_on_gpu.cpu().numpy()\n",
        "tensor_back_on_cpu"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "25hKyJQMz0YG",
        "outputId": "6473e479-05e2-451f-85a1-79fee4e720c1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1, 2, 3])"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tensor_on_gpu"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oMU0LWzy0KEg",
        "outputId": "097537c2-4f0e-4182-8d0e-5bae621d8de2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([1, 2, 3], device='cuda:0')"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "tensor_on_cpu = tensor.to('cpu')\n",
        "tensor_on_cpu, tensor_on_cpu.device"
      ],
      "metadata": {
        "id": "78JXNFvqzF9H"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "LHkpQ-DZ0Yoo"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "eUG5zBkc0jEQ"
      }
    }
  ]
}