00_pytorch_fundamentals.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyORPhCINCV3IXo0bhIW4I/w",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "gpuClass": "standard"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/maronem/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": [
        "\n",
        "0.0 PyTorch Fundamentals"
      ],
      "metadata": {
        "id": "-Uo0lZOpb-0a"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "wNT2vpDMbQKo"
      },
      "outputs": [],
      "source": [
        "#Changed runtime to GPU accelerator\n",
        "#!nvidia-smi"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Import dependencies\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "import torch\n",
        "print(torch.__version__)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0fKbFCBBbpQ_",
        "outputId": "76b3e708-e768-42de-bb3d-2e1174ef3945"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1.13.1+cu116\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Introduction to Tensors\n",
        "\n",
        "### Creating tensors\n",
        "\n",
        "PyTorch tesnors are created using torch.Tensor() = https://pytorch.org/docs/stable/tensors.html\n"
      ],
      "metadata": {
        "id": "CRnq_eGYdbRM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Scalar\n",
        "scalar = torch.tensor(7)\n",
        "print(scalar)\n",
        "\n",
        "#Get tensor back as Python int\n",
        "print(scalar.item())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wNOzzZ5SdRMG",
        "outputId": "f9086fb7-16a0-4382-e838-8d666bde1d38"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor(7)\n",
            "7\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "scalar.ndim"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SMyylo4TdPxS",
        "outputId": "8a2942d9-f6b8-43a4-ac74-de18866212bf"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Vector\n",
        "vector = torch.tensor([7,7])\n",
        "vector"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ePSBb-9heq1h",
        "outputId": "394ebd3a-2506-4991-e803-342d63c126a0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([7, 7])"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "vector.ndim"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ja7wdmTDe-Ql",
        "outputId": "705b3d34-7cd5-497f-f855-768ecfc740d3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "vector.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "w0q1kCYtfKYa",
        "outputId": "c48eb183-b515-45cb-b699-aaf62f3c2b60"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.Size([2])"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Matrix\n",
        "MATRIX = torch.tensor([[7,8],\n",
        "                       [9,10]])\n",
        "\n",
        "MATRIX"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XyQYZO0lfPiS",
        "outputId": "39cb9c6a-b304-4bb1-9a49-809b4e0f441c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[ 7,  8],\n",
              "        [ 9, 10]])"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "MATRIX.ndim"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "p8dXOCDUfhLj",
        "outputId": "8b92241f-e9bf-4703-bd2a-2017bfa9ffa3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "MATRIX[0]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qHJgf5oHfleJ",
        "outputId": "4a72dfff-09a7-4f0e-85b0-0d7dee981d64"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([7, 8])"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "MATRIX[1]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ahTPxdOqfpk4",
        "outputId": "0c5f8380-6528-4ae9-8de8-cec2006d26b7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([ 9, 10])"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "MATRIX.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jqU4yuiAfqSw",
        "outputId": "c50889e4-f846-40af-8bf4-dc10b918a491"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.Size([2, 2])"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Tensor\n",
        "TENSOR = torch.tensor([[[1,2,3],\n",
        "                        [4,5,6],\n",
        "                        [7,8,9]]])\n",
        "\n",
        "TENSOR"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "u37U_pjsftju",
        "outputId": "65dec640-c3f0-4a64-bba2-ecabd3ab8f20"
      },
      "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": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "TENSOR.ndim"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EXkzXt15gBqo",
        "outputId": "4d40a23a-0a93-4ac0-fcc4-25a927682294"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "TENSOR.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "z7dL5FiugIkt",
        "outputId": "14e01e4c-fe0d-4fc1-d7bf-43da04026863"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.Size([1, 3, 3])"
            ]
          },
          "metadata": {},
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "TENSOR[0]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tvf2_M1VgLob",
        "outputId": "cda0fe30-7eb2-496c-b34c-1a4359534f49"
      },
      "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": 16
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Tensor Practice\n",
        "TENSOR_FUN = torch.tensor([[[1,2,3,6],\n",
        "                            [4,5,6,6],\n",
        "                            [7,8,9,6],\n",
        "                            [9,8,7,6]]])\n",
        "\n",
        "TENSOR_FUN.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_pmcQPjzgVt_",
        "outputId": "1b15b14f-4624-4228-bf46-5733bf2c84fd"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.Size([1, 4, 4])"
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "TENSOR_FUN[0]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kfOwoSf8hR-z",
        "outputId": "8ef24e0a-642d-433c-93a5-d1932f01a684"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[1, 2, 3, 6],\n",
              "        [4, 5, 6, 6],\n",
              "        [7, 8, 9, 6],\n",
              "        [9, 8, 7, 6]])"
            ]
          },
          "metadata": {},
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Tensor shapes:\n",
        "\n",
        "ie. torch.Size([1,4,4]) = 1 Tensor containing 4 vectors within tensor, 4 elements within each vector"
      ],
      "metadata": {
        "id": "uXoOzQ6IhFs1"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Random Tensors\n",
        "\n",
        "Why random Tensors?\n",
        "\n",
        "Random tensors are important b/c the way many neural networks learn is by starting with tensors full of random numbers & adjust those #'s to better represent the data\n",
        "\n",
        "`Start with rand nums -> look at data -> update rand nums -> look at data -> update rand nums`\n",
        "\n",
        "torch.rand() -> https://pytorch.org/docs/stable/generated/torch.rand.html"
      ],
      "metadata": {
        "id": "F5GfVS7iEjGF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create rand tensor of size (3,4)\n",
        "\n",
        "rand_tensor = torch.rand(2,3,4)\n",
        "rand_tensor\n"
      ],
      "metadata": {
        "id": "Vbgrdhyhg4DZ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fd29b2eb-3fbb-4476-b896-b71d39c9881f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[[0.0275, 0.3801, 0.3142, 0.9229],\n",
              "         [0.9455, 0.7628, 0.2272, 0.0989],\n",
              "         [0.8733, 0.1103, 0.2180, 0.9046]],\n",
              "\n",
              "        [[0.0756, 0.5103, 0.3521, 0.8773],\n",
              "         [0.6588, 0.6049, 0.0921, 0.7474],\n",
              "         [0.5617, 0.7810, 0.5090, 0.9791]]])"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "rand_tensor.ndim"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6wPjAe1iFP3Q",
        "outputId": "c6c5e244-6884-4421-9470-0a5317dba8cd"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "metadata": {},
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "rand_tensor.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7vMbYsxGFW1Q",
        "outputId": "bdc6848f-352a-4966-9869-2279cc693c54"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.Size([2, 3, 4])"
            ]
          },
          "metadata": {},
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Create rand tensor with similar shape to an image tensor\n",
        "random_image_size_tensor = torch.rand(size=(3,224,224)) #color channels (RGB), height, width\n",
        "random_image_size_tensor.shape, random_image_size_tensor.ndim"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7CPID26zFY2q",
        "outputId": "71b3147c-6ac2-4cdd-f179-1b4c8b1aa264"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(torch.Size([3, 224, 224]), 3)"
            ]
          },
          "metadata": {},
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Zeros and ones"
      ],
      "metadata": {
        "id": "TKEOA_5dHCXh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create tensor of all zeros - useful for masking\n",
        "zeros = torch.zeros(size=(2,3,4))\n",
        "zeros"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oIPUagdPGTMY",
        "outputId": "7581ce5c-a7eb-464f-f9f8-5781f2bbc7f0"
      },
      "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.]],\n",
              "\n",
              "        [[0., 0., 0., 0.],\n",
              "         [0., 0., 0., 0.],\n",
              "         [0., 0., 0., 0.]]])"
            ]
          },
          "metadata": {},
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "zeros*rand_tensor #to multiply tensors, both tensors must be same shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "O5oacMstHK14",
        "outputId": "6bf0513c-0ac9-4a1b-c7fc-2b4db5a4451c"
      },
      "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.]],\n",
              "\n",
              "        [[0., 0., 0., 0.],\n",
              "         [0., 0., 0., 0.],\n",
              "         [0., 0., 0., 0.]]])"
            ]
          },
          "metadata": {},
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Create tensor of all ones\n",
        "ones = torch.ones(size=(3,4))\n",
        "ones"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ttrrgTZUHQT7",
        "outputId": "f4a98192-7b4e-429b-eafb-7ae4b19b6098"
      },
      "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": 25
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "ones.dtype #tensors will default to float32 numbers unless specified"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rOzM5j2VHfh5",
        "outputId": "74114807-2446-477b-edb5-28daa75a137a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.float32"
            ]
          },
          "metadata": {},
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Creating range of tensors and tensors-like"
      ],
      "metadata": {
        "id": "az-_2ylOIIFf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Use torch.range() - depricated, use torch.arange()\n",
        "one_to_ten = torch.arange(start=1,end=11, step=1) # or torch.arange(1,11,1)\n",
        "one_to_ten"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MLM70KIdHhc8",
        "outputId": "f19ddf8b-0b99-47cd-eb86-f6e5a034808f"
      },
      "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": 27
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Creating tensors-like - creates tensor of 0's with same shape as input tensor\n",
        "ten_zeros = torch.zeros_like(input=one_to_ten)\n",
        "ten_zeros"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xBSa8EgfIRaJ",
        "outputId": "cf4f7900-246a-4f88-ec54-f5583ee4f889"
      },
      "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": 28
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "fun_range = torch.arange(1,100,2)\n",
        "fun_range"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pEr0PB2YJBtI",
        "outputId": "401745f4-5294-4a27-c8af-2e56422d71cf"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([ 1,  3,  5,  7,  9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35,\n",
              "        37, 39, 41, 43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 63, 65, 67, 69, 71,\n",
              "        73, 75, 77, 79, 81, 83, 85, 87, 89, 91, 93, 95, 97, 99])"
            ]
          },
          "metadata": {},
          "execution_count": 29
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "fun_zeros = torch.zeros_like(input=(fun_range))\n",
        "fun_zeros"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rsygsxh2Jo8s",
        "outputId": "682db7ed-cfc1-4bc5-ff1f-67724de7c743"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
              "        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
              "        0, 0])"
            ]
          },
          "metadata": {},
          "execution_count": 30
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Tensor datatypes\n",
        "\n",
        "**Note:** Tensor dtypes is one of the 3 big errors you'll run into with PyTorch & deep learning\n",
        "\n",
        "1. Tensors not right dtype\n",
        "2. Tensors not right shape\n",
        "3. Tensors not on right device\n",
        "\n",
        "`requires_grad = True` allows you to calculate the derivative of the respective tensor using `.backward` method\n",
        "\n"
      ],
      "metadata": {
        "id": "cknBWB43J_bN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#float32 tensor = 32 & 16 bit refer to computing precision / detail / memory \n",
        "# 32-bit is standard, 16 bit is half-memory, 64-bit is double\n",
        "# lower bits = less computing time but also less precision\n",
        "float32_tensor = torch.tensor([3.0,6.0,9.0], \n",
        "                              dtype=None, #what datatype is the tensor (eg. float32, float16)\n",
        "                              device=None, #tensors must be on same device (ie. GPU or CPU)\n",
        "                              requires_grad=False) #Track gradient with this tensor's operations\n",
        "float32_tensor\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "j27Hcho0J_GZ",
        "outputId": "d67b29e6-ba52-418c-96b7-91c500c60f01"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([3., 6., 9.])"
            ]
          },
          "metadata": {},
          "execution_count": 31
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Create / modify to a float16 tensor\n",
        "float16_tensor = float32_tensor.type(torch.float16)\n",
        "float16_tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JFnE-uoMJxKs",
        "outputId": "acbc1f8a-94f3-41cd-b39e-c9f4ceb465e3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([3., 6., 9.], dtype=torch.float16)"
            ]
          },
          "metadata": {},
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "float16_tensor * float32_tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3WFLoiDUMYJY",
        "outputId": "aca069f5-f5ae-41a5-e0ac-c5552d1d1e86"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([ 9., 36., 81.])"
            ]
          },
          "metadata": {},
          "execution_count": 33
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "float_complex = float16_tensor.type(torch.complex64)\n",
        "float_complex"
      ],
      "metadata": {
        "id": "Uh4mYdjIMqRc",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5e0932af-925f-4947-ce3b-052a47616607"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([3.+0.j, 6.+0.j, 9.+0.j])"
            ]
          },
          "metadata": {},
          "execution_count": 34
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "float_complex.dtype"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "N1cYlzBMOT-z",
        "outputId": "774e0f70-95af-4e3a-c11a-573f363a1d22"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.complex64"
            ]
          },
          "metadata": {},
          "execution_count": 37
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "|float_complex*float16_tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8Rszp8zLNyMs",
        "outputId": "d1aa51bb-f5dc-41af-c7c6-765a3e6bb647"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([ 9.+0.j, 36.+0.j, 81.+0.j])"
            ]
          },
          "metadata": {},
          "execution_count": 35
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Getting information from Tensors\n",
        "\n",
        "1. Tensors not right dtype - to get `dtype` from a Tensor we can use `tensor.dtype`\n",
        "2. Tensors not right shape - to get `shape` use `tensor.shape`\n",
        "3. Tensors not on right device - to get `device` use `tensor.device`"
      ],
      "metadata": {
        "id": "OQ4wrO2XPTda"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a tensor\n",
        "\n",
        "some_tensor = torch.rand(4,6, dtype=torch.float16)\n",
        "some_tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZRV62CRKN0-o",
        "outputId": "6bfa99cf-f52c-4a38-f49a-514d7688edf7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[0.2256, 0.9819, 0.0581, 0.7495, 0.0840, 0.1792],\n",
              "        [0.2100, 0.1982, 0.8267, 0.1392, 0.7651, 0.7744],\n",
              "        [0.2466, 0.8169, 0.6914, 0.3003, 0.2070, 0.8403],\n",
              "        [0.6021, 0.0488, 0.5879, 0.2754, 0.8281, 0.1147]], dtype=torch.float16)"
            ]
          },
          "metadata": {},
          "execution_count": 44
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Find details about some_tensor (attributes)\n",
        "\n",
        "print(some_tensor)\n",
        "print(f\"Datatype of tensor: {some_tensor.dtype}\")\n",
        "print(f\"Shape of tensor: {some_tensor.shape}\")\n",
        "print(f\"Device tensor is on: {some_tensor.device}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UAPciFOwPpP4",
        "outputId": "768dee18-ab5d-4640-f56f-769f42c2574b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([[0.2256, 0.9819, 0.0581, 0.7495, 0.0840, 0.1792],\n",
            "        [0.2100, 0.1982, 0.8267, 0.1392, 0.7651, 0.7744],\n",
            "        [0.2466, 0.8169, 0.6914, 0.3003, 0.2070, 0.8403],\n",
            "        [0.6021, 0.0488, 0.5879, 0.2754, 0.8281, 0.1147]], dtype=torch.float16)\n",
            "Datatype of tensor: torch.float16\n",
            "Shape of tensor: torch.Size([4, 6])\n",
            "Device tensor is on: cpu\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Manipulating Tensors (tensor operations)\n",
        "\n",
        "Tensor operations include:\n",
        "* Addition\n",
        "* Subtraction\n",
        "* Multiplication (element-wise)\n",
        "* Division\n",
        "* Matrix multiplication"
      ],
      "metadata": {
        "id": "oQDzQK4RQovN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a tensor and add 10\n",
        "\n",
        "tensor = torch.tensor([1,2,3])\n",
        "\n",
        "tensor+10"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1YrYxNlqQB55",
        "outputId": "e819ee78-aada-409c-e892-01b4a9260ecc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([11, 12, 13])"
            ]
          },
          "metadata": {},
          "execution_count": 48
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Multiply tensor by 10\n",
        "\n",
        "tensor * 10"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vqn8leOcQWCF",
        "outputId": "3f2a055c-190e-4360-cb33-ec3c4546fd89"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([10, 20, 30])"
            ]
          },
          "metadata": {},
          "execution_count": 49
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Subtract 10 \n",
        "\n",
        "tensor - 10"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cRCOtNI7QV2n",
        "outputId": "ae3b6fb5-560b-4453-b342-dfd8bbf7f092"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([-9, -8, -7])"
            ]
          },
          "metadata": {},
          "execution_count": 50
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Try out PyTorch in-built functions\n",
        "\n",
        "torch.mul(tensor,10) #multiplication"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0u4wgrQQQVFz",
        "outputId": "a93824d8-c8b8-4ebc-807a-588dc4ff07b1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([10, 20, 30])"
            ]
          },
          "metadata": {},
          "execution_count": 51
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "torch.add(tensor,10)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DehjehLRQVc9",
        "outputId": "11df2293-7ca0-41cd-895e-44dec50683be"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([11, 12, 13])"
            ]
          },
          "metadata": {},
          "execution_count": 52
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Matrix multiplication\n",
        "\n",
        "To multiply matrices weneed to do the \"dot product\" - multiply matching members, then sum up\n",
        "\n",
        "ie. [1,2,3] * [7,8,9] = (1 * 7) + (2 * 8) + (3 * 9)\n",
        "\n",
        "More info on multplying matrices - https://www.mathsisfun.com/algebra/matrix-multiplying.html\n",
        "\n",
        "PyTorch implements matrix mult functionality in `torch.matmul()` method - `@` is the Py symbol for matrix multiplcation"
      ],
      "metadata": {
        "id": "8EBs-El-SB4c"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Element wise multiplcaiton\n",
        "\n",
        "print(tensor, \"*\", tensor)\n",
        "print(f\"Equals: {tensor * tensor}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qbYxONKCRtGM",
        "outputId": "41f79508-5989-44b9-a492-7500e444843b"
      },
      "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 multiplcation - output is the dot product (1+4+9)=14\n",
        "torch.matmul(tensor,tensor)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bJhF0rV-UaZx",
        "outputId": "2f3dd029-2f23-4e10-de60-c203e96a6db3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor(14)"
            ]
          },
          "metadata": {},
          "execution_count": 57
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "%%time\n",
        "value=0\n",
        "for i in range(len(tensor)):\n",
        "  value += tensor[i] * tensor[i]\n",
        "value"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pVBdmDP8UyjF",
        "outputId": "5467d559-bd4a-4169-b07c-d99c55fbb521"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "CPU times: user 261 µs, sys: 39 µs, total: 300 µs\n",
            "Wall time: 306 µs\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor(14)"
            ]
          },
          "metadata": {},
          "execution_count": 59
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "%%time \n",
        "torch.matmul(tensor,tensor)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lppLGc6XVeih",
        "outputId": "cb4f1e66-a971-463e-f456-b5a5fa57ac8b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "CPU times: user 108 µs, sys: 16 µs, total: 124 µs\n",
            "Wall time: 129 µs\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor(14)"
            ]
          },
          "metadata": {},
          "execution_count": 60
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Main two rules for matrix multiplication:\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",
        "\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": "AgaLc2nEWkB8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# The **inner dimensions** must match or error:\n",
        "torch.matmul(torch.rand(3,2), torch.rand(3,2))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 187
        },
        "id": "R6nNC3jYVl92",
        "outputId": "b694bb68-a77f-4edc-e181-861a5c13d42d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "RuntimeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-65-de0ac3826ab8>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# The **inner dimensions** must match or error:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmatmul\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrand\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrand\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\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;31mRuntimeError\u001b[0m: mat1 and mat2 shapes cannot be multiplied (3x2 and 3x2)"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# The **inner dimensions** must match:\n",
        "torch.matmul(torch.rand(2,3), torch.rand(3,2))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kEXS9gaQXLKT",
        "outputId": "6d8c0b1b-a19a-43dc-d60c-e364c1c9f3ef"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[0.7009, 0.4998],\n",
              "        [0.5691, 0.6204]])"
            ]
          },
          "metadata": {},
          "execution_count": 66
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# the resulting matrix has the shape of the **outer dimensions** (3,3)\n",
        "torch.matmul(torch.rand(3,10), torch.rand(10,3))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "St23fA-cXS4q",
        "outputId": "bdf42249-d299-4bb0-f18b-06220b1a5905"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[3.5545, 2.6634, 2.7133],\n",
              "        [3.2680, 2.4470, 2.5636],\n",
              "        [4.0000, 3.0489, 3.2627]])"
            ]
          },
          "metadata": {},
          "execution_count": 70
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### One of the most common errors in deep learning: shape errors"
      ],
      "metadata": {
        "id": "E3qyFp8LZWzy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Shapes for matrix multiplication\n",
        "tensor_A = torch.tensor([[1,2],\n",
        "                        [3,4],\n",
        "                        [5,6]])\n",
        "\n",
        "tensor_B = torch.tensor([[7,10],\n",
        "                        [8,11],\n",
        "                        [9,12]])\n",
        "\n",
        "torch.mm(tensor_A, tensor_B) #torch.mm same at torch.matmul"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 204
        },
        "id": "WsNLa_jmZWmh",
        "outputId": "1ce2d1c6-50a7-4ff1-81e8-6cfa38ba8ddf"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "RuntimeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-74-a2665613f7b4>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      8\u001b[0m                         [9,12]])\n\u001b[1;32m      9\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 10\u001b[0;31m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtensor_A\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtensor_B\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m#torch.mm same at torch.matmul\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mRuntimeError\u001b[0m: mat1 and mat2 shapes cannot be multiplied (3x2 and 3x2)"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tensor_A.shape, tensor_B.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "x3P7kbXjXuga",
        "outputId": "92684aea-0caf-45cb-adc8-49650bba0997"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(torch.Size([3, 2]), torch.Size([3, 2]))"
            ]
          },
          "metadata": {},
          "execution_count": 75
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "To fix tensor shape issues, we can manipulate the shape of one of our tensors using `transpose`\n",
        "\n",
        "A **transpose** switches axes/dims of a given tensor"
      ],
      "metadata": {
        "id": "h-xzBdITaY-i"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# original tensor B\n",
        "tensor_B, tensor_B.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_FqfMSTUalOe",
        "outputId": "f6b56171-15a0-48ba-b407-1c497135b922"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor([[ 7, 10],\n",
              "         [ 8, 11],\n",
              "         [ 9, 12]]), torch.Size([3, 2]))"
            ]
          },
          "metadata": {},
          "execution_count": 79
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# transposed tensor B\n",
        "tensor_B.T, tensor_B.T.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "29zyju4EaUun",
        "outputId": "81bda018-99e7-4131-f081-bfba29df4e5e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor([[ 7,  8,  9],\n",
              "         [10, 11, 12]]), torch.Size([2, 3]))"
            ]
          },
          "metadata": {},
          "execution_count": 80
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# The matrix multiplication operation works when tensor_B is transposed\n",
        "print(f\"Original shapes: tensor_A = {tensor_A.shape}, tensor_B = {tensor_B.shape}\")\n",
        "print(\"\\n\")\n",
        "print(f\"New shapes: tensor_A = {tensor_A.shape}, tensor_B = {tensor_B.T.shape}\")\n",
        "print(\"\\n\")\n",
        "torch.matmul(tensor_A, tensor_B.T), torch.matmul(tensor_A, tensor_B.T).shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "osxt0FhxaoGp",
        "outputId": "347ecaa8-555c-4888-c89b-7e1c1ff561d1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Original shapes: tensor_A = torch.Size([3, 2]), tensor_B = torch.Size([3, 2])\n",
            "\n",
            "\n",
            "New shapes: tensor_A = torch.Size([3, 2]), tensor_B = torch.Size([2, 3])\n",
            "\n",
            "\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor([[ 27,  30,  33],\n",
              "         [ 61,  68,  75],\n",
              "         [ 95, 106, 117]]), torch.Size([3, 3]))"
            ]
          },
          "metadata": {},
          "execution_count": 87
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(f\"tensor_A: {tensor_A.shape}\")\n",
        "print(f\"tensor_A transposed: {tensor_A.T.shape}\")\n",
        "print(f\"tensor_B: {tensor_B.shape}\")\n",
        "print(\"\\n\")\n",
        "print(torch.matmul(tensor_A.T, tensor_B))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TdzBWkeua_v4",
        "outputId": "5c5efba5-4023-4246-e3c6-e9a1f40419c8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor_A: torch.Size([3, 2])\n",
            "tensor_A transposed: torch.Size([2, 3])\n",
            "tensor_B: torch.Size([3, 2])\n",
            "\n",
            "\n",
            "tensor([[ 76, 103],\n",
            "        [100, 136]])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Find the min, max, mean, sum, etc (tensor aggregation)"
      ],
      "metadata": {
        "id": "m208LiSFcsJP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a tensor\n",
        "\n",
        "x = torch.arange(0,100,10)\n",
        "x"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iBVIqTpUcIZt",
        "outputId": "2934b07d-8f10-4e58-a043-5fea55919d3c"
      },
      "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": 108
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# find min\n",
        "\n",
        "torch.min(x), x.min()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QIp5SOisc980",
        "outputId": "41b5c5fc-47c0-4356-da7f-8fea3c87bd21"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor(0), tensor(0))"
            ]
          },
          "metadata": {},
          "execution_count": 109
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# find max\n",
        "\n",
        "torch.max(x), x.max()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IYm2kFjedAvG",
        "outputId": "86843a97-3faf-44c7-c60a-6a7e47f2b2fe"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor(90), tensor(90))"
            ]
          },
          "metadata": {},
          "execution_count": 110
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# find mean - note: torch.mean() requires tensor dtype of float or complex\n",
        "torch.mean(x, dtype=torch.float32), x.type(torch.float32).mean()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IHI2L9SldEWm",
        "outputId": "cf798cf3-9713-4bf5-888d-2946a6165994"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor(45.), tensor(45.))"
            ]
          },
          "metadata": {},
          "execution_count": 115
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# find sum\n",
        "\n",
        "torch.sum(x), x.sum()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0_kjd7pMdJCO",
        "outputId": "c1bbc280-4b96-4ec5-daac-c9b6317f6454"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor(450), tensor(450))"
            ]
          },
          "metadata": {},
          "execution_count": 116
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# find index or positional min/max - argmin() or argmax() functions\n",
        "print(x)\n",
        "print(\"\\n\")\n",
        "print(f\"min: {torch.min(x)}\")\n",
        "print(f\"Index of min: [{torch.argmin(x)}]\")\n",
        "print(\"\\n\")\n",
        "print(f\"max: {torch.max(x)}\")\n",
        "print(f\"Index of max: [{torch.argmax(x)}]\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "X_IpYo9yd7YT",
        "outputId": "1d1860a4-07be-49b3-ebd6-fc1967a65a4b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([ 0, 10, 20, 30, 40, 50, 60, 70, 80, 90])\n",
            "\n",
            "\n",
            "min: 0\n",
            "Index of min: [0]\n",
            "\n",
            "\n",
            "max: 90\n",
            "Index of max: [9]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "au1e6Qk8eRzo"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}