00_Pytorch_Fundamentals.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 262,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bJJXcqFsDDkX",
        "outputId": "079e4a2c-4a49-4892-9706-2441a8741eb0"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "/bin/bash: line 1: nvidia-smi: command not found\n"
          ]
        }
      ],
      "source": [
        "! nvidia-smi"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 263,
      "metadata": {
        "id": "Glp-W-UlDwXM"
      },
      "outputs": [],
      "source": [
        "import torch\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6mPGGgeu7H22"
      },
      "source": [
        "**Learning about tensors**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 264,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HIlqXn8MZ-pi",
        "outputId": "ac42d8ef-a872-407e-e99c-5fe09d96b332"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor(9)"
            ]
          },
          "execution_count": 264,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "scalar = torch.tensor(9)\n",
        "scalar"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 265,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sr4ivR5PglYb",
        "outputId": "999a73db-e57a-49c3-85c6-68084f2806c0"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "execution_count": 265,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "scalar.ndim"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 266,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "U3GVnC7Ygnzh",
        "outputId": "97bd9def-5dfe-46f1-dfb6-6a239e96c5a6"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "torch.Size([])"
            ]
          },
          "execution_count": 266,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "scalar.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 267,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yVdrKMvlgqHj",
        "outputId": "8499acad-3b15-430d-9a40-c6c170583e86"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([1, 2, 3, 4])"
            ]
          },
          "execution_count": 267,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "vector = torch.tensor([1,2,3,4])\n",
        "vector"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 268,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2Amn7ndag2c7",
        "outputId": "9a649991-beac-4117-842b-c69154b97e4b"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "execution_count": 268,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "vector.ndim"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 269,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6_UXS34Ng6CT",
        "outputId": "5824871c-3414-48bf-b9bd-bd0f40eccfe3"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "torch.Size([4])"
            ]
          },
          "execution_count": 269,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "vector.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 270,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4P1F8-AFg7nr",
        "outputId": "bbdf83de-c9ff-4481-b75b-ff6d3a078235"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([[3, 1],\n",
              "        [2, 4],\n",
              "        [5, 0],\n",
              "        [6, 7]])"
            ]
          },
          "execution_count": 270,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "MATRIX = torch.tensor([[3,1],[2,4],[5,0],[6,7]])\n",
        "MATRIX"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 271,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yJFw3SbihG77",
        "outputId": "240e7084-a1f1-4be5-b8f2-5c8f46f9ae1d"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "execution_count": 271,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "MATRIX.ndim"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 272,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jYmgAybdhb9e",
        "outputId": "d64fca34-88f9-459d-bd5a-aa276726814a"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "torch.Size([4, 2])"
            ]
          },
          "execution_count": 272,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "MATRIX.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 273,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eA_5Gv4fhc6Q",
        "outputId": "440550d4-1688-4f77-88b5-18f5311b0a0c"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([[[[[1, 2, 3],\n",
              "           [4, 5, 6],\n",
              "           [7, 8, 9]],\n",
              "\n",
              "          [[1, 2, 3],\n",
              "           [4, 5, 6],\n",
              "           [7, 8, 9]]],\n",
              "\n",
              "\n",
              "         [[[1, 2, 3],\n",
              "           [4, 5, 6],\n",
              "           [7, 8, 9]],\n",
              "\n",
              "          [[1, 2, 3],\n",
              "           [4, 5, 6],\n",
              "           [7, 8, 9]]]]])"
            ]
          },
          "execution_count": 273,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "TENSOR = torch.tensor([[[[[1,2,3],[4,5,6],[7,8,9]],[[1,2,3],[4,5,6],[7,8,9]]],[[[1,2,3],[4,5,6],[7,8,9]],[[1,2,3],[4,5,6],[7,8,9]]]]])\n",
        "TENSOR"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 274,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JivzCXbnhwMG",
        "outputId": "e6a65923-7167-44ad-cd17-9ec2d187ab3a"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "5"
            ]
          },
          "execution_count": 274,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "TENSOR.ndim"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 275,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KF2GHbxThy8x",
        "outputId": "7cd6b0fd-54db-48e4-9fbe-eb6a5c025b26"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "torch.Size([1, 2, 2, 3, 3])"
            ]
          },
          "execution_count": 275,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "TENSOR.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 276,
      "metadata": {
        "id": "ZFiHeTqPh0Zg"
      },
      "outputs": [],
      "source": [
        "# The number of sqaure bracket pair at first corresponidng to that at last (they will be highest in number) and correspond to the dimension of the tensor\n",
        "# To every dimension corresponds to a shape , logic of which is based on comma seperated values and square brackets."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 277,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FY0_gqcqwesx",
        "outputId": "bc07f3ec-f04c-4a5e-d79c-258a48664a6a"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "torch.Size([2, 5])"
            ]
          },
          "execution_count": 277,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Construct a tensor of shape (2,3,2,5) , step by step\n",
        "TENSOR = torch.tensor([[1,1,1,1,1],[1,1,1,1,1]])\n",
        "TENSOR.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 278,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CIKUkrLuxF6f",
        "outputId": "f2811872-98e1-4e0f-8cf7-330893567c30"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "torch.Size([3, 2, 5])"
            ]
          },
          "execution_count": 278,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "TENSOR = torch.tensor([[[1,1,1,1,1],[1,1,1,1,1]],[[1,1,1,1,1],[1,1,1,1,1]],[[1,1,1,1,1],[1,1,1,1,1]]])\n",
        "TENSOR.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 279,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Q0Aw_mzhxpCG",
        "outputId": "e80fd23b-6b3e-4738-c462-96dcb9b6158b"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "torch.Size([2, 3, 2, 5])"
            ]
          },
          "execution_count": 279,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "TENSOR = torch.tensor([[[[1,1,1,1,1],[1,1,1,1,1]],[[1,1,1,1,1],[1,1,1,1,1]],[[1,1,1,1,1],[1,1,1,1,1]]],[[[1,1,1,1,1],[1,1,1,1,1]],[[1,1,1,1,1],[1,1,1,1,1]],[[1,1,1,1,1],[1,1,1,1,1]]]])\n",
        "TENSOR.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 280,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_M3voN65xzzy",
        "outputId": "a877bd88-0ae9-4139-f2c5-ea7b049a8e55"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([[[[1, 1, 1, 1, 1],\n",
              "          [1, 1, 1, 1, 1]],\n",
              "\n",
              "         [[1, 1, 1, 1, 1],\n",
              "          [1, 1, 1, 1, 1]],\n",
              "\n",
              "         [[1, 1, 1, 1, 1],\n",
              "          [1, 1, 1, 1, 1]]],\n",
              "\n",
              "\n",
              "        [[[1, 1, 1, 1, 1],\n",
              "          [1, 1, 1, 1, 1]],\n",
              "\n",
              "         [[1, 1, 1, 1, 1],\n",
              "          [1, 1, 1, 1, 1]],\n",
              "\n",
              "         [[1, 1, 1, 1, 1],\n",
              "          [1, 1, 1, 1, 1]]]])"
            ]
          },
          "execution_count": 280,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "TENSOR"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 281,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xXC8pklrx2Kl",
        "outputId": "11ad5ed2-a561-49b2-a092-e34b85d04d6e"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "tensor([[[[[ 1,  2],\n",
            "           [ 3,  4]],\n",
            "\n",
            "          [[ 5,  6],\n",
            "           [ 7,  8]]],\n",
            "\n",
            "\n",
            "         [[[ 9, 10],\n",
            "           [11, 12]],\n",
            "\n",
            "          [[13, 14],\n",
            "           [15, 16]]]],\n",
            "\n",
            "\n",
            "\n",
            "        [[[[17, 18],\n",
            "           [19, 20]],\n",
            "\n",
            "          [[21, 22],\n",
            "           [23, 24]]],\n",
            "\n",
            "\n",
            "         [[[25, 26],\n",
            "           [27, 28]],\n",
            "\n",
            "          [[29, 30],\n",
            "           [31, 32]]]]])\n"
          ]
        }
      ],
      "source": [
        "long_tensor = torch.arange(1, 2**5 + 1, dtype=torch.long).reshape(2, 2, 2, 2, 2)\n",
        "\n",
        "print(long_tensor) # This is (2,2,2,2,2) shape tensor"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 282,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hBwT7MTqyPid",
        "outputId": "29dc215a-b68d-4753-d3ca-1976af29c9ea"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "torch.Size([2, 2, 2, 2, 2])"
            ]
          },
          "execution_count": 282,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "long_tensor.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 283,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0VDvGELV5hOU",
        "outputId": "b6b4d68b-adaa-49c2-cc1b-0dba4a40257a"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor(24)"
            ]
          },
          "execution_count": 283,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Access 24\n",
        "long_tensor[1][0][1][1][1]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 284,
      "metadata": {
        "id": "2CJAfrQAy94e"
      },
      "outputs": [],
      "source": [
        "# In shape the 0th index corresponds to highest sq bracket and last index corresponds to scalers present in one pair of sq bracket []."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 285,
      "metadata": {
        "id": "bpZrKy5nz1jE"
      },
      "outputs": [],
      "source": [
        "# tensor shape (3,224,224) - [[[1,1,.....224],[1,1,.....224]....... 224]],[[1,1,.....224],[1,1,.....224],[1,1,.....224].......224]],[[1,1,.....224],[1,1,.....224]...........224]]]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 286,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MzoSXbmJ1SzO",
        "outputId": "28d0f0aa-8ce6-4bd9-8073-cf1f064c4141"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "execution_count": 286,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# To fetch single item from a tensor\n",
        "x = torch.tensor(1)\n",
        "x.item()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aUlSgbc062S_"
      },
      "source": [
        "**Random Tensors**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 287,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AMHQn0w21aXt",
        "outputId": "59b8bd5f-af24-4adc-b55f-5eddc4f40898"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([[0.4318, 0.4078, 0.3224, 0.7408],\n",
              "        [0.7730, 0.7708, 0.7673, 0.9595],\n",
              "        [0.6836, 0.6906, 0.9440, 0.6093],\n",
              "        [0.4180, 0.0040, 0.0114, 0.2454]])"
            ]
          },
          "execution_count": 287,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Random Tensor\n",
        "torch.rand(4,4)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 288,
      "metadata": {
        "id": "7b_nEx8N5lfi"
      },
      "outputs": [],
      "source": [
        "x = torch.rand(3,224,224)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 289,
      "metadata": {
        "id": "RAUBz6rh5q6G"
      },
      "outputs": [],
      "source": [
        "y = torch.rand(224,224,3)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 290,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rWjibDs050J8",
        "outputId": "d30d1ea2-3d48-4a32-994f-8c7c3315cb9c"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "torch.Size([3, 224, 224])"
            ]
          },
          "execution_count": 290,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "x.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 291,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DcA6MdS2589o",
        "outputId": "1e09e481-a038-4b01-8d3a-2ac3ba01e4b3"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "torch.Size([224, 224, 3])"
            ]
          },
          "execution_count": 291,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "y.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 292,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kEIbr9c85-2r",
        "outputId": "2470dfa9-0bd0-4fc5-df5f-d86874440a2f"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "execution_count": 292,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "x.ndim"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 293,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tCTcbPq06Ar4",
        "outputId": "0d214647-ead6-4116-c2a1-9b8789583f46"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "execution_count": 293,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "y.ndim"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 294,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xmzJwBSe6B7q",
        "outputId": "8a02a728-3aaa-4567-99f8-8e58c595e7bd"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([[[0.4882, 0.5544, 0.8100,  ..., 0.5117, 0.6969, 0.5971],\n",
              "         [0.9649, 0.8254, 0.2365,  ..., 0.1605, 0.5538, 0.8629],\n",
              "         [0.8437, 0.9670, 0.0119,  ..., 0.8576, 0.9341, 0.3329],\n",
              "         ...,\n",
              "         [0.4264, 0.6988, 0.8864,  ..., 0.7425, 0.4719, 0.3662],\n",
              "         [0.6174, 0.0940, 0.5256,  ..., 0.6268, 0.7652, 0.8626],\n",
              "         [0.3348, 0.2294, 0.3055,  ..., 0.7323, 0.2592, 0.8807]],\n",
              "\n",
              "        [[0.1384, 0.4593, 0.5274,  ..., 0.1854, 0.7141, 0.2492],\n",
              "         [0.4447, 0.5815, 0.8517,  ..., 0.3110, 0.0621, 0.7833],\n",
              "         [0.4663, 0.4661, 0.5897,  ..., 0.2358, 0.7307, 0.4859],\n",
              "         ...,\n",
              "         [0.9113, 0.1853, 0.1536,  ..., 0.5148, 0.8019, 0.0823],\n",
              "         [0.5464, 0.4962, 0.3416,  ..., 0.5495, 0.9629, 0.6521],\n",
              "         [0.9446, 0.2243, 0.1175,  ..., 0.7973, 0.0495, 0.8444]],\n",
              "\n",
              "        [[0.6528, 0.0278, 0.7328,  ..., 0.4301, 0.7482, 0.9345],\n",
              "         [0.0825, 0.3372, 0.3036,  ..., 0.0166, 0.5163, 0.0842],\n",
              "         [0.0979, 0.3193, 0.3515,  ..., 0.1698, 0.2514, 0.1682],\n",
              "         ...,\n",
              "         [0.4553, 0.2894, 0.8360,  ..., 0.5302, 0.2247, 0.6946],\n",
              "         [0.7146, 0.1250, 0.7293,  ..., 0.8038, 0.2321, 0.7550],\n",
              "         [0.5995, 0.3997, 0.8180,  ..., 0.6751, 0.0016, 0.2538]]])"
            ]
          },
          "execution_count": 294,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "x"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 295,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IoDnH9H06Dyp",
        "outputId": "bdc5b886-7b92-4590-aa5c-c8cadafb7bc7"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([[[0.0354, 0.1926, 0.1746],\n",
              "         [0.3552, 0.1228, 0.2126],\n",
              "         [0.6673, 0.7482, 0.5106],\n",
              "         ...,\n",
              "         [0.3022, 0.7069, 0.9493],\n",
              "         [0.0689, 0.3427, 0.4325],\n",
              "         [0.2173, 0.0044, 0.7066]],\n",
              "\n",
              "        [[0.1448, 0.6636, 0.3360],\n",
              "         [0.7173, 0.3597, 0.7988],\n",
              "         [0.1203, 0.5260, 0.9898],\n",
              "         ...,\n",
              "         [0.6111, 0.0143, 0.3447],\n",
              "         [0.7950, 0.4898, 0.9403],\n",
              "         [0.0262, 0.7709, 0.1274]],\n",
              "\n",
              "        [[0.8414, 0.2946, 0.2297],\n",
              "         [0.5611, 0.7261, 0.5117],\n",
              "         [0.1417, 0.6309, 0.5461],\n",
              "         ...,\n",
              "         [0.5559, 0.9924, 0.5042],\n",
              "         [0.0184, 0.2624, 0.0458],\n",
              "         [0.3774, 0.6381, 0.1980]],\n",
              "\n",
              "        ...,\n",
              "\n",
              "        [[0.1853, 0.1780, 0.5479],\n",
              "         [0.4328, 0.2643, 0.1761],\n",
              "         [0.5525, 0.9643, 0.0449],\n",
              "         ...,\n",
              "         [0.5102, 0.7575, 0.0249],\n",
              "         [0.7919, 0.1360, 0.4395],\n",
              "         [0.6062, 0.8844, 0.7000]],\n",
              "\n",
              "        [[0.4433, 0.6560, 0.3065],\n",
              "         [0.8848, 0.4823, 0.9382],\n",
              "         [0.7176, 0.0877, 0.6340],\n",
              "         ...,\n",
              "         [0.1955, 0.4585, 0.3019],\n",
              "         [0.3059, 0.5549, 0.2532],\n",
              "         [0.9885, 0.2259, 0.8995]],\n",
              "\n",
              "        [[0.7014, 0.5574, 0.4074],\n",
              "         [0.1146, 0.3976, 0.8013],\n",
              "         [0.5468, 0.3465, 0.3124],\n",
              "         ...,\n",
              "         [0.5876, 0.9046, 0.2743],\n",
              "         [0.5030, 0.0816, 0.1797],\n",
              "         [0.8190, 0.5548, 0.0719]]])"
            ]
          },
          "execution_count": 295,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "y"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fqTsnMmi7pM9"
      },
      "source": [
        "**Tesnor of zeros and one**\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 296,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "g5XfVW2t7vsG",
        "outputId": "3eb62069-8989-4071-d4a0-6117e92549a3"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([[0., 0., 0., 0.],\n",
              "        [0., 0., 0., 0.],\n",
              "        [0., 0., 0., 0.]])"
            ]
          },
          "execution_count": 296,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "torch.zeros(3,4)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 297,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RSsbcTe272EN",
        "outputId": "7d1ac0a3-96f7-4f37-d6e6-c91ebe9ce703"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([[1., 1., 1., 1.],\n",
              "        [1., 1., 1., 1.],\n",
              "        [1., 1., 1., 1.]])"
            ]
          },
          "execution_count": 297,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "torch.ones(3,4)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "T2rYUeAXGgyy"
      },
      "source": [
        "**arange and tensor like**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 298,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6rYSNqX878XO",
        "outputId": "98e58165-e8d6-4494-91cc-08529bb8cfac"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([ 3,  9, 15, 21, 27, 33, 39, 45, 51, 57, 63, 69, 75, 81, 87, 93, 99])"
            ]
          },
          "execution_count": 298,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# In arange start , end , step are the arguments\n",
        "x = torch.arange(3,100,6)\n",
        "x"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 299,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cPGELvq-7_7Q",
        "outputId": "832f8ca7-e456-41a2-9d42-7fd3227d008f"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([[0., 0., 0., 0., 0., 0.],\n",
              "        [0., 0., 0., 0., 0., 0.],\n",
              "        [0., 0., 0., 0., 0., 0.],\n",
              "        [0., 0., 0., 0., 0., 0.]])"
            ]
          },
          "execution_count": 299,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# torch.zeros_like(input) , it will create tensor with same size as input\n",
        "tensor = torch.empty(4,6)\n",
        "torch.zeros_like(tensor)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 300,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "93LoaJigHD1k",
        "outputId": "d2f80e7b-7527-4989-aa8f-5ad753729f5e"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([[ 0.0000e+00,  0.0000e+00, -2.9609e-11,  3.1491e-41, -2.8375e-12,\n",
              "          3.1491e-41],\n",
              "        [-2.1615e-33,  4.5719e-41,  0.0000e+00,  0.0000e+00,  0.0000e+00,\n",
              "          0.0000e+00],\n",
              "        [ 0.0000e+00,  0.0000e+00,  0.0000e+00,  0.0000e+00,  0.0000e+00,\n",
              "          0.0000e+00],\n",
              "        [ 0.0000e+00,  0.0000e+00,  1.4013e-45,  0.0000e+00,  0.0000e+00,\n",
              "          0.0000e+00]])"
            ]
          },
          "execution_count": 300,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "tensor"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6PIv_h_YJ89g"
      },
      "source": [
        "**Tensor has 3 arguments in it , dtype - for data type , device like cuda or \"cpu\" , requires_grad to check gradients.**\n",
        "\n",
        "The Default datatype for tensor is float32"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 301,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vXh8lrjWHF10",
        "outputId": "b118c7a4-2404-420d-aaa5-16674e0b9ef3"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "torch.float32"
            ]
          },
          "execution_count": 301,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "tensor = torch.zeros(3,4)\n",
        "tensor.dtype # default"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 302,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zvVcOaeNKlIh",
        "outputId": "72c25cc9-429e-428d-a39f-b792e7800704"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "torch.float16"
            ]
          },
          "execution_count": 302,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "tensor = torch.zeros(3,4, dtype=torch.float16)\n",
        "tensor.dtype"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 303,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kNraYCd3KzIJ",
        "outputId": "77d9636e-d32e-4d97-db5f-cfb087f1958c"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([[0, 0, 0, 0],\n",
              "        [0, 0, 0, 0],\n",
              "        [0, 0, 0, 0]], dtype=torch.int16)"
            ]
          },
          "execution_count": 303,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Using type function\n",
        "tensor_1 = tensor.type(torch.int16)\n",
        "tensor_1"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 304,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "V5VhfZOzLGjX",
        "outputId": "7a8af5bd-60d6-4c77-afeb-738ae357797c"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([[0.3700, 0.4079, 0.5283, 0.2411],\n",
              "        [0.8577, 0.2081, 0.1457, 0.2165],\n",
              "        [0.6897, 0.7573, 0.6393, 0.2684]])"
            ]
          },
          "execution_count": 304,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "x = torch.rand(3,4)\n",
        "x"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 305,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6nCiOYfZLi9B",
        "outputId": "172fd9a7-246c-4320-a332-9fce1973f997"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "torch.float32"
            ]
          },
          "execution_count": 305,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "x.dtype"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 306,
      "metadata": {
        "id": "qIqFBkxGLlJV"
      },
      "outputs": [],
      "source": [
        "y = x.type(torch.int64) # the data type gets converted to the argument written inside type and tensor remains same."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 307,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sGbhExw1LsMp",
        "outputId": "6827a103-6fb9-490e-a3c2-16b463e5a182"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([[0, 0, 0, 0],\n",
              "        [0, 0, 0, 0],\n",
              "        [0, 0, 0, 0]])"
            ]
          },
          "execution_count": 307,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "y"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XXh-26stMDcn"
      },
      "source": [
        "The 3 most common errors seen in while coding pytorch via tensors\n",
        "1. Tensors not right data type\n",
        "2. Tensors not right shape\n",
        "3. Tensors not on right device."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 308,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CvOFr_BwNUFv",
        "outputId": "f02b0311-2232-44d6-e35d-c696e90dee4d"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "The datatype of tensor is torch.float32\n",
            "The shape of tensor is torch.Size([3, 4])\n",
            "The device of tensor is cpu\n"
          ]
        }
      ],
      "source": [
        "tensor = torch.rand(3,4) #Gattering info of the most imp thing from tensors\n",
        "print(f\"The datatype of tensor is {tensor.dtype}\")\n",
        "print(f\"The shape of tensor is {tensor.shape}\")\n",
        "print(f\"The device of tensor is {tensor.device}\")\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VXBubLd-SGnY"
      },
      "source": [
        "## Manipulating tensors (tensor operations)\n",
        "\n",
        "In deep learning, data (images, text, video, audio, protein structures, etc) gets represented as tensors.\n",
        "\n",
        "A model learns by investigating those tensors and performing a series of operations (could be 1,000,000s+) on tensors to create a representation of the patterns in the input data.\n",
        "\n",
        "These operations are often a wonderful dance between:\n",
        "* Addition\n",
        "* Substraction\n",
        "* Multiplication (element-wise)\n",
        "* Division\n",
        "* Matrix multiplication"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 309,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8h786EGYSJ7W",
        "outputId": "66bf488d-44c1-42b4-e943-1be58fff3d52"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([[0.5510, 0.1298, 0.4707, 0.9479],\n",
              "        [0.7727, 0.3618, 0.0619, 0.9691],\n",
              "        [0.7939, 0.9154, 0.7615, 0.7594]])"
            ]
          },
          "execution_count": 309,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "tensor = torch.rand(3,4)\n",
        "tensor"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 310,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bqKgWYqCXGxR",
        "outputId": "55ef2715-cb5d-4f26-fe41-ce91af637e66"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Result of tensor + 10 - tensor([[10.5510, 10.1298, 10.4707, 10.9479],\n",
            "        [10.7727, 10.3618, 10.0619, 10.9691],\n",
            "        [10.7939, 10.9154, 10.7615, 10.7594]])\n",
            "\n",
            " Result of tensor.add(tensor,10) - tensor([[10.5510, 10.1298, 10.4707, 10.9479],\n",
            "        [10.7727, 10.3618, 10.0619, 10.9691],\n",
            "        [10.7939, 10.9154, 10.7615, 10.7594]])\n",
            "\n",
            "tensor([[5.5099, 1.2980, 4.7068, 9.4787],\n",
            "        [7.7272, 3.6183, 0.6189, 9.6906],\n",
            "        [7.9392, 9.1540, 7.6146, 7.5944]])\n"
          ]
        }
      ],
      "source": [
        "print(f\"Result of tensor + 10 - {tensor + 10}\")\n",
        "print(f\"\\n Result of tensor.add(tensor,10) - {torch.add(tensor,10)}\\n\") # same like above alternative command\n",
        "# Like that\n",
        "print(tensor*10)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 311,
      "metadata": {
        "id": "OwpQ08ALX5KY"
      },
      "outputs": [],
      "source": [
        "# Matrix Multiplication is main thing , Matrix is 2 dimentional tensor , torch.mm or torch.matmul and @ is used for Matrix Multiplication."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 312,
      "metadata": {
        "id": "w-H2E14Cabny"
      },
      "outputs": [],
      "source": [
        "# We can write the code for matrix multiplication by hands on by for loop but it's not reccommended , coz pytorch used it's optimal vectorization in matrix multiplication in matmul."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 313,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "odQAHyIrc1st",
        "outputId": "1194d457-560d-454b-dd47-bdfe5591c529"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Tensor A:\n",
            "tensor([[9, 9],\n",
            "        [9, 8],\n",
            "        [2, 2]], dtype=torch.int32)\n",
            "\n",
            "Tensor B:\n",
            "tensor([[2, 8],\n",
            "        [8, 6],\n",
            "        [3, 8]], dtype=torch.int32)\n",
            "\n"
          ]
        }
      ],
      "source": [
        "# Create a tensor of random integers with shape (3, 2) and dtype int32\n",
        "tensor_A = torch.randint(0, 10, (3, 2), dtype=torch.int32)\n",
        "\n",
        "# Create a tensor of random floats with shape (3, 2) and convert to int32\n",
        "tensor_B = torch.randint(0, 10, (3, 2), dtype=torch.int32)\n",
        "\n",
        "print(f\"Tensor A:\\n{tensor_A}\\n\")\n",
        "print(f\"Tensor B:\\n{tensor_B}\\n\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 314,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KpJxzv0seHdl",
        "outputId": "d42ed8d9-fa91-4620-aad6-ba76399aa8e9"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([[2, 8, 3],\n",
              "        [8, 6, 8]], dtype=torch.int32)"
            ]
          },
          "execution_count": 314,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "tensor_B.T # Taking transpose applying .T to the matrix"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 315,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jBYF0u_CdHjQ",
        "outputId": "c8e4ac1d-723c-4641-f21b-ef54699d3b78"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([[ 90, 126,  99],\n",
              "        [ 82, 120,  91],\n",
              "        [ 20,  28,  22]], dtype=torch.int32)"
            ]
          },
          "execution_count": 315,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "torch.matmul(tensor_A,tensor_B.T)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 316,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XBk2uiv7eBhZ",
        "outputId": "b6a0142f-bf84-4be2-cb1e-5b52e53331c1"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Original shapes: tensor_A = torch.Size([3, 2]), tensor_B = torch.Size([3, 2])\n",
            "\n",
            "New shapes: tensor_A = torch.Size([3, 2]) (same as above), tensor_B.T = torch.Size([2, 3])\n",
            "\n",
            "Multiplying: torch.Size([3, 2]) * torch.Size([2, 3]) <- inner dimensions match\n",
            "\n",
            "Output:\n",
            "\n",
            "tensor([[ 90, 126,  99],\n",
            "        [ 82, 120,  91],\n",
            "        [ 20,  28,  22]], dtype=torch.int32)\n",
            "\n",
            "Output shape: torch.Size([3, 3])\n"
          ]
        }
      ],
      "source": [
        "# The operation works when tensor_B is transposed\n",
        "print(f\"Original shapes: tensor_A = {tensor_A.shape}, tensor_B = {tensor_B.shape}\\n\")\n",
        "print(f\"New shapes: tensor_A = {tensor_A.shape} (same as above), tensor_B.T = {tensor_B.T.shape}\\n\")\n",
        "print(f\"Multiplying: {tensor_A.shape} * {tensor_B.T.shape} <- inner dimensions match\\n\")\n",
        "print(\"Output:\\n\")\n",
        "output = torch.matmul(tensor_A, tensor_B.T)\n",
        "print(output)\n",
        "print(f\"\\nOutput shape: {output.shape}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 317,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "n_YEQnI3evtx",
        "outputId": "24b1f268-a9de-4802-d88a-e777e2e5a6be"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "tensor([ 0, 10, 20, 30, 40, 50, 60, 70, 80, 90])\n",
            "\n",
            "max value is 90 and can also be fed from torch.max(x) which gives 90\n",
            "min value is 0\n",
            "mean value is 45.0\n",
            "sum value is 450\n"
          ]
        }
      ],
      "source": [
        "# Finding min max sum mean in tensor\n",
        "x = torch.arange(0,100,10)\n",
        "print(f\"{x}\\n\")\n",
        "print(f\"max value is {x.max()} and can also be fed from torch.max(x) which gives {torch.max(x)}\")\n",
        "print(f\"min value is {x.min()}\")\n",
        "print(f\"mean value is {x.type(torch.float32).mean()}\")  # The error of not right data type came up , the mean doesn't get applied to int 64 , Longint dtype\n",
        "print(f\"sum value is {x.sum()}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 318,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zBEt2upxlpIW",
        "outputId": "97a7754b-4a83-4c30-a644-cf020def4506"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([[0.1441, 0.3401, 0.6634],\n",
              "        [0.0210, 0.2901, 0.4719]])"
            ]
          },
          "execution_count": 318,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "y = torch.rand(2,3)\n",
        "y"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 319,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Klur4ciDmr8X",
        "outputId": "a7342c2f-dc08-47ae-dc72-221c7f099a97"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor(0.3218)"
            ]
          },
          "execution_count": 319,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "torch.mean(y)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 320,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Z-8RjB7LmwiD",
        "outputId": "792f22d7-6d27-4d3f-b56e-af2d92545bb5"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor(2)"
            ]
          },
          "execution_count": 320,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Finding the position or index that is argmin() , argmax() to find where does it occur\n",
        "y.argmax()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 321,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "73JBS7MbwGpr",
        "outputId": "b3c90a61-1100-4115-ed2d-7e5283ed0ecc"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor(3)"
            ]
          },
          "execution_count": 321,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "y.argmin()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gsL3p02pxi5A"
      },
      "source": [
        "### Reshaping, stacking, squeezing and unsqueezing\n",
        "\n",
        "Often times you'll want to reshape or change the dimensions of your tensors without actually changing the values inside them.\n",
        "\n",
        "To do so, some popular methods are:\n",
        "\n",
        "| Method | One-line description |\n",
        "| ----- | ----- |\n",
        "| [`torch.reshape(input, shape)`](https://pytorch.org/docs/stable/generated/torch.reshape.html#torch.reshape) | Reshapes `input` to `shape` (if compatible), can also use `torch.Tensor.reshape()`. |\n",
        "| [`Tensor.view(shape)`](https://pytorch.org/docs/stable/generated/torch.Tensor.view.html) | Returns a view of the original tensor in a different `shape` but shares the same data as the original tensor. |\n",
        "| [`torch.stack(tensors, dim=0)`](https://pytorch.org/docs/1.9.1/generated/torch.stack.html) | Concatenates a sequence of `tensors` along a new dimension (`dim`), all `tensors` must be same size. |\n",
        "| [`torch.squeeze(input)`](https://pytorch.org/docs/stable/generated/torch.squeeze.html) | Squeezes `input` to remove all the dimenions with value `1`. |\n",
        "| [`torch.unsqueeze(input, dim)`](https://pytorch.org/docs/1.9.1/generated/torch.unsqueeze.html) | Returns `input` with a dimension value of `1` added at `dim`. |\n",
        "| [`torch.permute(input, dims)`](https://pytorch.org/docs/stable/generated/torch.permute.html) | Returns a *view* of the original `input` with its dimensions permuted (rearranged) to `dims`. |\n",
        "\n",
        "Why do any of these?\n",
        "\n",
        "Because deep learning models (neural networks) are all about manipulating tensors in some way. And because of the rules of matrix multiplication, if you've got shape mismatches, you'll run into errors. These methods help you make sure the right elements of your tensors are mixing with the right elements of other tensors.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 322,
      "metadata": {
        "id": "EhYuiDxOwKIt"
      },
      "outputs": [],
      "source": [
        "# No of elements should remain same"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 323,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xFtS16oK32bV",
        "outputId": "5975227d-13dc-45ae-9bca-cf9c9ef5c416"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([1, 2, 3, 4, 5, 6, 7, 8, 9])"
            ]
          },
          "execution_count": 323,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "x = torch.arange(1,10)\n",
        "x"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 324,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0w70wbbk3_Te",
        "outputId": "c3e59b15-ea4e-4e02-fd87-6bfaf9ad5ea9"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "torch.Size([9])"
            ]
          },
          "execution_count": 324,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "x.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 325,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xsgQpDt04C1L",
        "outputId": "44d84443-48fd-4b7c-f04e-c72ea9a03888"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([[1, 2, 3],\n",
              "        [4, 5, 6],\n",
              "        [7, 8, 9]])"
            ]
          },
          "execution_count": 325,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "x.reshape(3,3)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 326,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GoxvNUtT4OzD",
        "outputId": "f5d5de73-7fb3-4f0b-ce3e-ebf3e70e0f33"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([1, 2, 3, 4, 5, 6, 7, 8, 9])"
            ]
          },
          "execution_count": 326,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "x"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 327,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1cHEMhsr4TyL",
        "outputId": "87c9122a-20ad-4524-f0ce-31a916f9279e"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([[0.8643, 0.5919, 0.7483, 0.4759],\n",
              "        [0.6945, 0.6318, 0.3488, 0.6021],\n",
              "        [0.5678, 0.2791, 0.7283, 0.1858],\n",
              "        [0.4350, 0.8956, 0.5706, 0.6664],\n",
              "        [0.6840, 0.8941, 0.1689, 0.2513],\n",
              "        [0.7443, 0.4160, 0.1105, 0.3843],\n",
              "        [0.6247, 0.4382, 0.7152, 0.6605],\n",
              "        [0.4538, 0.2856, 0.8886, 0.1439]])"
            ]
          },
          "execution_count": 327,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "y = torch.rand(8,4)\n",
        "y"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 328,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kEsILL084dzR",
        "outputId": "a42e2e88-a618-4fcf-cbdd-5d33e0e89693"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([[[0.8643, 0.5919, 0.7483, 0.4759],\n",
              "         [0.6945, 0.6318, 0.3488, 0.6021]],\n",
              "\n",
              "        [[0.5678, 0.2791, 0.7283, 0.1858],\n",
              "         [0.4350, 0.8956, 0.5706, 0.6664]],\n",
              "\n",
              "        [[0.6840, 0.8941, 0.1689, 0.2513],\n",
              "         [0.7443, 0.4160, 0.1105, 0.3843]],\n",
              "\n",
              "        [[0.6247, 0.4382, 0.7152, 0.6605],\n",
              "         [0.4538, 0.2856, 0.8886, 0.1439]]])"
            ]
          },
          "execution_count": 328,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "y.reshape(4,2,4)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 329,
      "metadata": {
        "id": "pOVuMsxL4nYP"
      },
      "outputs": [],
      "source": [
        "z = x.view(3,3)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 330,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5oN1b6o45EkA",
        "outputId": "6565b1cf-8e9e-4bdf-cbf5-558aba397e9e"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([[1, 2, 3],\n",
              "        [4, 5, 6],\n",
              "        [7, 8, 9]])"
            ]
          },
          "execution_count": 330,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "z"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 331,
      "metadata": {
        "id": "AKo2jV2c5FOw"
      },
      "outputs": [],
      "source": [
        "z[0] = 51 # z is allocated in same meory as x."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 332,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eEcA4v9g5Je1",
        "outputId": "738ff16a-0cf9-4b42-b9fc-e0aa026f3483"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(tensor([51, 51, 51,  4,  5,  6,  7,  8,  9]),\n",
              " tensor([[51, 51, 51],\n",
              "         [ 4,  5,  6],\n",
              "         [ 7,  8,  9]]))"
            ]
          },
          "execution_count": 332,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "x,z"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 333,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2tV54MUb5KuQ",
        "outputId": "b1cbf712-09b8-42d8-e39e-042c37c5b4e9"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([51, 51, 51,  4,  5,  6,  7,  8,  9])"
            ]
          },
          "execution_count": 333,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "x"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 334,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3faRUfHL7MHx",
        "outputId": "a0d1c589-1246-4287-ca07-8cf5f138e24f"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([[51, 51, 51],\n",
              "        [51, 51, 51],\n",
              "        [51, 51, 51],\n",
              "        [ 4,  4,  4],\n",
              "        [ 5,  5,  5],\n",
              "        [ 6,  6,  6],\n",
              "        [ 7,  7,  7],\n",
              "        [ 8,  8,  8],\n",
              "        [ 9,  9,  9]])"
            ]
          },
          "execution_count": 334,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "torch.stack([x,x,x],dim=1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 335,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ifzF31Uf7bXs",
        "outputId": "6c74db5b-0600-453c-85ea-e8c8314e9d6f"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "torch.Size([9, 3])"
            ]
          },
          "execution_count": 335,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "torch.stack([x,x,x],dim=1).shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 336,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "knYiasSw7uRA",
        "outputId": "f0b4950b-fc79-4129-a1a5-3524dad214f1"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "torch.Size([9])"
            ]
          },
          "execution_count": 336,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "x.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 337,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5XesmCHG7v4e",
        "outputId": "3cb4f252-3cd7-4fa4-9531-3f23737b1c93"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "execution_count": 337,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "torch.stack([x,x,x],dim=1).ndim"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 338,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pv4doUft704-",
        "outputId": "347b4ebc-e335-4312-e373-956a43b51f7f"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "execution_count": 338,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "x.ndim"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 339,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rLpwXD7y8yuR",
        "outputId": "51bbb4eb-9c91-4911-ce12-f78163f47c32"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([[0.8643, 0.5919, 0.7483, 0.4759],\n",
              "        [0.6945, 0.6318, 0.3488, 0.6021],\n",
              "        [0.5678, 0.2791, 0.7283, 0.1858],\n",
              "        [0.4350, 0.8956, 0.5706, 0.6664],\n",
              "        [0.6840, 0.8941, 0.1689, 0.2513],\n",
              "        [0.7443, 0.4160, 0.1105, 0.3843],\n",
              "        [0.6247, 0.4382, 0.7152, 0.6605],\n",
              "        [0.4538, 0.2856, 0.8886, 0.1439]])"
            ]
          },
          "execution_count": 339,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "y"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 340,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RK3tJfO_76WX",
        "outputId": "b823142e-8a40-44e8-af0f-92c584f36a57"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([[[0.8643, 0.5919, 0.7483, 0.4759],\n",
              "         [0.8643, 0.5919, 0.7483, 0.4759],\n",
              "         [0.8643, 0.5919, 0.7483, 0.4759]],\n",
              "\n",
              "        [[0.6945, 0.6318, 0.3488, 0.6021],\n",
              "         [0.6945, 0.6318, 0.3488, 0.6021],\n",
              "         [0.6945, 0.6318, 0.3488, 0.6021]],\n",
              "\n",
              "        [[0.5678, 0.2791, 0.7283, 0.1858],\n",
              "         [0.5678, 0.2791, 0.7283, 0.1858],\n",
              "         [0.5678, 0.2791, 0.7283, 0.1858]],\n",
              "\n",
              "        [[0.4350, 0.8956, 0.5706, 0.6664],\n",
              "         [0.4350, 0.8956, 0.5706, 0.6664],\n",
              "         [0.4350, 0.8956, 0.5706, 0.6664]],\n",
              "\n",
              "        [[0.6840, 0.8941, 0.1689, 0.2513],\n",
              "         [0.6840, 0.8941, 0.1689, 0.2513],\n",
              "         [0.6840, 0.8941, 0.1689, 0.2513]],\n",
              "\n",
              "        [[0.7443, 0.4160, 0.1105, 0.3843],\n",
              "         [0.7443, 0.4160, 0.1105, 0.3843],\n",
              "         [0.7443, 0.4160, 0.1105, 0.3843]],\n",
              "\n",
              "        [[0.6247, 0.4382, 0.7152, 0.6605],\n",
              "         [0.6247, 0.4382, 0.7152, 0.6605],\n",
              "         [0.6247, 0.4382, 0.7152, 0.6605]],\n",
              "\n",
              "        [[0.4538, 0.2856, 0.8886, 0.1439],\n",
              "         [0.4538, 0.2856, 0.8886, 0.1439],\n",
              "         [0.4538, 0.2856, 0.8886, 0.1439]]])"
            ]
          },
          "execution_count": 340,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "torch.stack([y,y,y],dim=1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 341,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "D6K77wn-9rHK",
        "outputId": "92d22fba-2c68-4873-f67e-d676d7c502e4"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "torch.Size([8, 3, 4])"
            ]
          },
          "execution_count": 341,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "torch.stack([y,y,y],dim=1).shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 342,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xj0kE3v98rQT",
        "outputId": "0cd6635d-cbbe-4f62-ae46-ac30265ae89d"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([[[0.8643, 0.5919, 0.7483, 0.4759],\n",
              "         [0.6945, 0.6318, 0.3488, 0.6021],\n",
              "         [0.5678, 0.2791, 0.7283, 0.1858],\n",
              "         [0.4350, 0.8956, 0.5706, 0.6664],\n",
              "         [0.6840, 0.8941, 0.1689, 0.2513],\n",
              "         [0.7443, 0.4160, 0.1105, 0.3843],\n",
              "         [0.6247, 0.4382, 0.7152, 0.6605],\n",
              "         [0.4538, 0.2856, 0.8886, 0.1439]],\n",
              "\n",
              "        [[0.8643, 0.5919, 0.7483, 0.4759],\n",
              "         [0.6945, 0.6318, 0.3488, 0.6021],\n",
              "         [0.5678, 0.2791, 0.7283, 0.1858],\n",
              "         [0.4350, 0.8956, 0.5706, 0.6664],\n",
              "         [0.6840, 0.8941, 0.1689, 0.2513],\n",
              "         [0.7443, 0.4160, 0.1105, 0.3843],\n",
              "         [0.6247, 0.4382, 0.7152, 0.6605],\n",
              "         [0.4538, 0.2856, 0.8886, 0.1439]],\n",
              "\n",
              "        [[0.8643, 0.5919, 0.7483, 0.4759],\n",
              "         [0.6945, 0.6318, 0.3488, 0.6021],\n",
              "         [0.5678, 0.2791, 0.7283, 0.1858],\n",
              "         [0.4350, 0.8956, 0.5706, 0.6664],\n",
              "         [0.6840, 0.8941, 0.1689, 0.2513],\n",
              "         [0.7443, 0.4160, 0.1105, 0.3843],\n",
              "         [0.6247, 0.4382, 0.7152, 0.6605],\n",
              "         [0.4538, 0.2856, 0.8886, 0.1439]]])"
            ]
          },
          "execution_count": 342,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "torch.stack([y,y,y],dim=0)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 343,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "U2SLycht9oXI",
        "outputId": "b4807485-f264-4eec-bea8-55ee15f44572"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "torch.Size([3, 8, 4])"
            ]
          },
          "execution_count": 343,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "torch.stack([y,y,y],dim=0).shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 344,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "svX8-DGB90rD",
        "outputId": "3c6e5e84-ca13-4a9c-b3d5-bcadb417be12"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "torch.Size([8, 4])"
            ]
          },
          "execution_count": 344,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "y.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 345,
      "metadata": {
        "id": "ocNFEyqj95I_"
      },
      "outputs": [],
      "source": [
        "# So the as we stacked 3 tensors it would be added with an extra dimension"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 346,
      "metadata": {
        "id": "7524IVe7-NkG"
      },
      "outputs": [],
      "source": [
        "# squeezeing the tensor , it returns a tensor with all specified dimensions of input of size 1 removed."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 347,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "I6asixvBVl4a",
        "outputId": "6d216610-e51f-4023-dc50-fd6e400d7d3c"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([12, 13, 14, 15, 16, 17, 18, 19, 20])"
            ]
          },
          "execution_count": 347,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "Tensor_C = torch.arange(12,21)\n",
        "Tensor_C"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 348,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cum7tUQDV2Mi",
        "outputId": "95da68ff-03cc-406e-d29d-aa5f46e0aa68"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([[12],\n",
              "        [13],\n",
              "        [14],\n",
              "        [15],\n",
              "        [16],\n",
              "        [17],\n",
              "        [18],\n",
              "        [19],\n",
              "        [20]])"
            ]
          },
          "execution_count": 348,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "Tensor_C.reshape(9,1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 349,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZE_A3gLZV-4c",
        "outputId": "b8244671-19f9-4837-9e2c-14ec6db7416e"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "torch.Size([9, 1])"
            ]
          },
          "execution_count": 349,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "Tensor_C.reshape(9,1).shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 350,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Y7aCON2qWCxn",
        "outputId": "7510de24-72c2-4bf4-c3df-471696533802"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "torch.Size([9])"
            ]
          },
          "execution_count": 350,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "Tensor_C.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 351,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2YVEArcEWE9F",
        "outputId": "6974ad9f-88c0-4a81-f9e2-da5e23c44b84"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([12, 13, 14, 15, 16, 17, 18, 19, 20])"
            ]
          },
          "execution_count": 351,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "Tensor_C.reshape(9,1).squeeze()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 352,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ohH38-37WH2X",
        "outputId": "060e5d09-bae4-4f79-bd69-ec081dae797a"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "torch.Size([9])"
            ]
          },
          "execution_count": 352,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "Tensor_C.reshape(9,1).squeeze().shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 353,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bT58AkJNWKLi",
        "outputId": "15b22945-1a69-48cb-b6b7-51ad36b913e9"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([[[[[8.5118e-02, 3.0772e-01, 5.6678e-01, 7.9210e-01]],\n",
              "\n",
              "          [[4.2841e-01, 3.5636e-01, 2.0901e-01, 8.7147e-01]],\n",
              "\n",
              "          [[1.8773e-01, 9.6104e-01, 2.4166e-01, 8.4010e-01]]]],\n",
              "\n",
              "\n",
              "\n",
              "        [[[[7.9907e-01, 6.5245e-01, 6.8737e-01, 5.8138e-01]],\n",
              "\n",
              "          [[9.0998e-04, 1.9753e-01, 8.8357e-01, 7.3619e-01]],\n",
              "\n",
              "          [[4.0335e-01, 5.0786e-01, 9.8973e-02, 1.9327e-01]]]]])"
            ]
          },
          "execution_count": 353,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "tensor_x = torch.rand(2,1,3,1,4)\n",
        "tensor_x"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 354,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bqTWlLMVWTd5",
        "outputId": "90f8e9aa-00d9-4ee9-e39b-1bd0d60af6a8"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([[[8.5118e-02, 3.0772e-01, 5.6678e-01, 7.9210e-01],\n",
              "         [4.2841e-01, 3.5636e-01, 2.0901e-01, 8.7147e-01],\n",
              "         [1.8773e-01, 9.6104e-01, 2.4166e-01, 8.4010e-01]],\n",
              "\n",
              "        [[7.9907e-01, 6.5245e-01, 6.8737e-01, 5.8138e-01],\n",
              "         [9.0998e-04, 1.9753e-01, 8.8357e-01, 7.3619e-01],\n",
              "         [4.0335e-01, 5.0786e-01, 9.8973e-02, 1.9327e-01]]])"
            ]
          },
          "execution_count": 354,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "tensor_x_squeezed = tensor_x.squeeze()\n",
        "tensor_x_squeezed"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 355,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "j7c70Kh3Ws3B",
        "outputId": "97278fc0-a137-48ae-850d-ec6e21b7df2c"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "torch.Size([2, 3, 4])"
            ]
          },
          "execution_count": 355,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "tensor_x_squeezed.shape # All the dims with dimension 1 got squeezed."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 356,
      "metadata": {
        "id": "rxLOPGYSWv6M"
      },
      "outputs": [],
      "source": [
        "tensor_y = torch.squeeze(tensor_x , 1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 357,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ES46vesxXS6r",
        "outputId": "bbef8abd-3463-4975-d35e-424761fbc93f"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "torch.Size([2, 3, 1, 4])"
            ]
          },
          "execution_count": 357,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "tensor_y.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 358,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9JVYdmtMXcFn",
        "outputId": "c3abd44b-6272-40a4-deb5-d4a8b856bd0b"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "torch.Size([2, 1, 3, 1, 4])"
            ]
          },
          "execution_count": 358,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "torch.squeeze(tensor_x , 0).shape # NO change , because at 0th dimension there was not 1 diemsnion"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 359,
      "metadata": {
        "id": "BXQDmZNCXvgf"
      },
      "outputs": [],
      "source": [
        "# Tensor size - (2,4,2,1,3) 2 is 0th dimension , 4 is 1st dimension , 2 is 2nd dimension , 1 is 3rd dimesnion , 3 is 4th dimension and overall ndim is 5 , outher sq bracket is 0th dim and as we move inside the dim increases"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 360,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KjRLImbjYO0C",
        "outputId": "8aa21f6a-aa78-408e-bf46-d6e9db893f49"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "torch.Size([2, 3, 1, 4])"
            ]
          },
          "execution_count": 360,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "torch.squeeze(tensor_x , 1).shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 361,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OhBaIMWXYeyb",
        "outputId": "19397331-8587-4a5d-c74c-79fb5604b231"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "torch.Size([2, 1, 3, 1, 4])"
            ]
          },
          "execution_count": 361,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "torch.squeeze(tensor_x , 2).shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 362,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7Xmu52VGZGCR",
        "outputId": "43d60a79-438d-4acd-9a95-c558a5d691aa"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "torch.Size([2, 1, 3, 4])"
            ]
          },
          "execution_count": 362,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "torch.squeeze(tensor_x , 3).shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 363,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BG87PfoyZI6N",
        "outputId": "e218a90e-da7c-4bf8-e18c-01894c5d695b"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "torch.Size([2, 1, 3, 1, 4])"
            ]
          },
          "execution_count": 363,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# unsqueeze , adds a dimension of 1 at specified dimension.\n",
        "tensor_x.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 364,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5PbbYo4zbKfr",
        "outputId": "8df66d9c-1e37-4ec2-cf1a-c4c14c40b40d"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "torch.Size([1, 2, 1, 3, 1, 4])"
            ]
          },
          "execution_count": 364,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "tensor_x.unsqueeze(0).shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 365,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mfWYlPz8bQJY",
        "outputId": "755c1250-0f84-42a7-fbc9-ebe0c8b41785"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "torch.Size([1, 2, 3, 1, 4])"
            ]
          },
          "execution_count": 365,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "torch.permute(tensor_x , (1,0,2,3,4)).shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 366,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zh63PWGlbq-q",
        "outputId": "5a270d54-cc76-4292-f191-408f232f63b6"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([[[[[8.5118e-02, 3.0772e-01, 5.6678e-01, 7.9210e-01]],\n",
              "\n",
              "          [[4.2841e-01, 3.5636e-01, 2.0901e-01, 8.7147e-01]],\n",
              "\n",
              "          [[1.8773e-01, 9.6104e-01, 2.4166e-01, 8.4010e-01]]],\n",
              "\n",
              "\n",
              "         [[[7.9907e-01, 6.5245e-01, 6.8737e-01, 5.8138e-01]],\n",
              "\n",
              "          [[9.0998e-04, 1.9753e-01, 8.8357e-01, 7.3619e-01]],\n",
              "\n",
              "          [[4.0335e-01, 5.0786e-01, 9.8973e-02, 1.9327e-01]]]]])"
            ]
          },
          "execution_count": 366,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "torch.permute(tensor_x , (1,0,2,3,4))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 367,
      "metadata": {
        "id": "T1cWSQZqb76W"
      },
      "outputs": [],
      "source": [
        "torch.permute(tensor_x , (1,0,2,3,4))[0][0][0][0][0] = 1"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 368,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3zRNWyJ2hcR9",
        "outputId": "4862c3d9-562b-4c3a-f9d5-4aad82ed29fe"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([[[[[1.0000e+00, 3.0772e-01, 5.6678e-01, 7.9210e-01]],\n",
              "\n",
              "          [[4.2841e-01, 3.5636e-01, 2.0901e-01, 8.7147e-01]],\n",
              "\n",
              "          [[1.8773e-01, 9.6104e-01, 2.4166e-01, 8.4010e-01]]]],\n",
              "\n",
              "\n",
              "\n",
              "        [[[[7.9907e-01, 6.5245e-01, 6.8737e-01, 5.8138e-01]],\n",
              "\n",
              "          [[9.0998e-04, 1.9753e-01, 8.8357e-01, 7.3619e-01]],\n",
              "\n",
              "          [[4.0335e-01, 5.0786e-01, 9.8973e-02, 1.9327e-01]]]]])"
            ]
          },
          "execution_count": 368,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "tensor_x # the permute shares same memory with original tensor , so change in permuted will change the original"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 369,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Jkl6_898hiDP",
        "outputId": "920fe4cc-6c33-4a0b-8280-9c1622f67feb"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "torch.Size([2, 1, 3, 1, 4])"
            ]
          },
          "execution_count": 369,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "tensor_x.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 370,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RYbQyMx_hs6P",
        "outputId": "6104b356-a12e-4500-bf56-acf1b3c140e0"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([[[13, 23, 28],\n",
              "         [89, 56,  9],\n",
              "         [72, 68, 84]],\n",
              "\n",
              "        [[10, 66, 71],\n",
              "         [53, 10, 22],\n",
              "         [ 6, 91, 97]],\n",
              "\n",
              "        [[79, 96, 68],\n",
              "         [86, 35, 47],\n",
              "         [59, 93,  8]],\n",
              "\n",
              "        [[ 3, 15, 64],\n",
              "         [30, 79, 22],\n",
              "         [30, 21,  1]]], dtype=torch.int32)"
            ]
          },
          "execution_count": 370,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Indeixng\n",
        "z = torch.randint(0, 100 , (4, 3, 3), dtype=torch.int32)\n",
        "z"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 371,
      "metadata": {
        "id": "GndotUmCj1xW"
      },
      "outputs": [],
      "source": [
        "# You can use \":\" to select \"all\" of a target dimension"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 372,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "T84qmhFIkdQj",
        "outputId": "e999ae3d-2540-4ba8-9427-9dd388024405"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([], size=(0, 3, 3), dtype=torch.int32)"
            ]
          },
          "execution_count": 372,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "z[1:0]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 373,
      "metadata": {
        "id": "ZvD5ocJk5_iE"
      },
      "outputs": [],
      "source": [
        "# For now not able to understand \":\" this slicing."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Zq7GxVBSc4MY"
      },
      "source": [
        "\n",
        "PyTorch tensors & NumPy\n",
        "Since NumPy is a popular Python numerical computing library, PyTorch has functionality to interact with it nicely.\n",
        "\n",
        "The two main methods you'll want to use for NumPy to PyTorch (and back again) are:\n",
        "\n",
        "torch.from_numpy(ndarray) - NumPy array -> PyTorch tensor.\n",
        "torch.Tensor.numpy() - PyTorch tensor -> NumPy array."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 374,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ye_g42l3c5LD",
        "outputId": "09f266e7-1f3c-4b00-d7af-d3be20781663"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([1., 2., 3., 4., 5., 6., 7.])"
            ]
          },
          "execution_count": 374,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "array = np.arange(1.0, 8.0)\n",
        "array"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 375,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hnVBptJDdzqp",
        "outputId": "33924e5d-5dde-4092-d2d4-e66d3dbeac64"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "dtype('float64')"
            ]
          },
          "execution_count": 375,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "array.dtype"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 376,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dMZHHpDrd1O5",
        "outputId": "73824aa5-9aea-4c45-fa57-442150e9c48e"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([1., 2., 3., 4., 5., 6., 7.], dtype=torch.float64)"
            ]
          },
          "execution_count": 376,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "tensor = torch.from_numpy(array) # Altough the default data type of pytorch is float 32 , but for numpy is float 64 so while converting numpy to pytorch the data type we got was of default numpy\n",
        "tensor"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 377,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1qNRs7rnd6lc",
        "outputId": "0b851d99-b9fc-41a3-d202-9aeff0c2b84c"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([1., 2., 3., 4., 5., 6., 7.])"
            ]
          },
          "execution_count": 377,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "tensor.type(torch.float32)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 378,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dyasY7PfeUKe",
        "outputId": "9c2c41df-26d4-4eea-e327-e2382e8e92ce"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([2., 3., 4., 5., 6., 7., 8.])"
            ]
          },
          "execution_count": 378,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "array = array + 1\n",
        "array"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 379,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lHamCCy0eYpa",
        "outputId": "ffd8b1da-6050-44d3-b48a-213f558f08da"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([1., 2., 3., 4., 5., 6., 7.], dtype=torch.float64)"
            ]
          },
          "execution_count": 379,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "tensor # It's a new copy"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 380,
      "metadata": {
        "id": "2dTQYLzrejKW"
      },
      "outputs": [],
      "source": [
        "x = torch.rand(3,4)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 381,
      "metadata": {
        "id": "NnGbSJ3JfRD4"
      },
      "outputs": [],
      "source": [
        "numpy_array = torch.Tensor.numpy(x)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 382,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UjUWh71KfVnn",
        "outputId": "456aced7-ccab-4bc0-e6c5-6b1b94a66eb2"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[0.45541793, 0.16880685, 0.82999337, 0.88572425],\n",
              "       [0.48422706, 0.95326734, 0.5533615 , 0.25066   ],\n",
              "       [0.0722214 , 0.53053415, 0.37226623, 0.76096916]], dtype=float32)"
            ]
          },
          "execution_count": 382,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "numpy_array"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 383,
      "metadata": {
        "id": "plenhk4hfbY_"
      },
      "outputs": [],
      "source": [
        "x = x + 2"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 384,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Yk6eOw9Rfe2W",
        "outputId": "9da343b0-4862-4339-f6f9-6b5f2e550c9f"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([[2.4554, 2.1688, 2.8300, 2.8857],\n",
              "        [2.4842, 2.9533, 2.5534, 2.2507],\n",
              "        [2.0722, 2.5305, 2.3723, 2.7610]])"
            ]
          },
          "execution_count": 384,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "x"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 385,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qzuOFyZ9ffd8",
        "outputId": "c2728d14-ee5d-4dab-fd11-5db0d976848e"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[0.45541793, 0.16880685, 0.82999337, 0.88572425],\n",
              "       [0.48422706, 0.95326734, 0.5533615 , 0.25066   ],\n",
              "       [0.0722214 , 0.53053415, 0.37226623, 0.76096916]], dtype=float32)"
            ]
          },
          "execution_count": 385,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "numpy_array"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 386,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fyZ1G5G7fjDw",
        "outputId": "553950df-1f91-4a51-b1e6-107daa5dcc8b"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "execution_count": 386,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "torch.cuda.is_available()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 387,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "id": "_3CM3Q0Qugqw",
        "outputId": "0cab0aef-06f2-462b-8269-98a463554c25"
      },
      "outputs": [
        {
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'cpu'"
            ]
          },
          "execution_count": 387,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Set device type\n",
        "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
        "device"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 388,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iO4I3-yzvs-g",
        "outputId": "c873a68a-313c-418e-d269-cb148a80d738"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "execution_count": 388,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Count number of devices\n",
        "torch.cuda.device_count()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "GP_vGDWCv0Kt"
      },
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "gpuType": "T4",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}