00_pytorch_fundamentals_exercises.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "view-in-github"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/ReImage-CollegeProject/Learn_PyTorch/blob/main/00_pytorch_fundamentals_exercises.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AzDBM_v4iMe7"
      },
      "source": [
        "# 00. PyTorch Fundamentals Exercises\n",
        "\n",
        "### 1. Documentation reading\n",
        "\n",
        "A big part of deep learning (and learning to code in general) is getting familiar with the documentation of a certain framework you're using. We'll be using the PyTorch documentation a lot throughout the rest of this course. So I'd recommend spending 10-minutes reading the following (it's okay if you don't get some things for now, the focus is not yet full understanding, it's awareness):\n",
        "  * The documentation on [`torch.Tensor`](https://pytorch.org/docs/stable/tensors.html#torch-tensor).\n",
        "  * The documentation on [`torch.cuda`](https://pytorch.org/docs/master/notes/cuda.html#cuda-semantics).\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "bGD0oD8Kizak"
      },
      "outputs": [],
      "source": [
        "# No code solution (reading)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2YSCWfcu5WGx",
        "outputId": "aaf95589-3bbc-4a29-e0a7-02c572c216c3"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(tensor([[0.8655, 0.5894, 0.6564, 0.9211],\n",
              "         [0.4065, 0.8307, 0.0572, 0.2359],\n",
              "         [0.9890, 0.5521, 0.3723, 0.5671]]),\n",
              " torch.float32,\n",
              " device(type='cpu'))"
            ]
          },
          "execution_count": 19,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "import torch\n",
        "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
        "\n",
        "tensor = torch.rand(3,4)\n",
        "tensor, tensor.dtype, tensor.device"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "juhIntZd5XXf",
        "outputId": "ae0f9304-1eeb-400e-a821-1fdc73e150f0"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(tensor([[0.8655, 0.5894, 0.6564, 0.9211],\n",
              "         [0.4065, 0.8307, 0.0572, 0.2359],\n",
              "         [0.9890, 0.5521, 0.3723, 0.5671]], device='cuda:0'),\n",
              " device(type='cuda', index=0),\n",
              " torch.float32)"
            ]
          },
          "execution_count": 20,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "tensor_on_gpu = tensor.to(device)\n",
        "tensor_on_gpu, tensor_on_gpu.device, tensor_on_gpu.dtype"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wI-77wET5WqT",
        "outputId": "74685e29-87c4-4ea8-8e4b-60f91ec0a276"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(tensor([2., 3., 4., 5.], device='cuda:0'),\n",
              " device(type='cuda', index=0),\n",
              " torch.float32)"
            ]
          },
          "execution_count": 9,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "InUlj_kg5XH_",
        "outputId": "56e53585-001f-483d-f11f-3849d9d7d7af"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(tensor([3, 4, 5, 5]), torch.int64, device(type='cpu'))"
            ]
          },
          "execution_count": 18,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "__iXqqz-ioUJ"
      },
      "source": [
        "### 2. Create a random tensor with shape `(7, 7)`.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6pUq9Dc8i2L7",
        "outputId": "582013a2-5e4a-40bd-f20b-832ed4024310"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(tensor([[0.4478, 0.3479, 0.5835, 0.1932, 0.1635, 0.2397, 0.3381],\n",
              "         [0.2306, 0.7390, 0.6256, 0.2438, 0.7198, 0.9323, 0.1181],\n",
              "         [0.4820, 0.1010, 0.5228, 0.4566, 0.1312, 0.4200, 0.5537],\n",
              "         [0.5619, 0.2351, 0.2003, 0.9458, 0.7950, 0.7336, 0.2686],\n",
              "         [0.3304, 0.7321, 0.3331, 0.6881, 0.0597, 0.2772, 0.5933],\n",
              "         [0.6900, 0.7859, 0.4775, 0.0871, 0.3373, 0.9501, 0.5092],\n",
              "         [0.1259, 0.4754, 0.0827, 0.2503, 0.0850, 0.7520, 0.7514]]),\n",
              " 2,\n",
              " torch.Size([7, 7]),\n",
              " torch.float32,\n",
              " device(type='cpu'))"
            ]
          },
          "execution_count": 15,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Import torch\n",
        "\n",
        "import torch\n",
        "\n",
        "# Create random tensor\n",
        "random_tensor_A = torch.rand(7,7)\n",
        "random_tensor_A, random_tensor_A.ndim, random_tensor_A.size(), random_tensor_A.dtype, random_tensor_A.device"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9-XxvRLfiqkR"
      },
      "source": [
        "### 3. Perform a matrix multiplication on the tensor from 2 with another random tensor with shape `(1, 7)` (hint: you may have to transpose the second tensor)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 29,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NcLqR0Sbi_vT",
        "outputId": "86f14c47-8e8c-46c1-f79e-1ea72640f686"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(tensor([[1.1981],\n",
              "         [1.5420],\n",
              "         [1.4412],\n",
              "         [1.7016],\n",
              "         [1.7518],\n",
              "         [1.6827],\n",
              "         [1.2795]]),\n",
              " 2,\n",
              " torch.Size([7, 1]),\n",
              " torch.float32,\n",
              " device(type='cpu'))"
            ]
          },
          "execution_count": 29,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Create another random tensor\n",
        "\n",
        "random_tensor_B = torch.rand(1,7)\n",
        "\n",
        "# Perform matrix multiplication\n",
        "mul_res = torch.matmul(random_tensor_A, random_tensor_B.T)\n",
        "mul_res, mul_res.ndim, mul_res.size(), mul_res.dtype, mul_res.device"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eiutdKUFiryU"
      },
      "source": [
        "### 4. Set the random seed to `0` and do 2 & 3 over again.\n",
        "\n",
        "The output should be:\n",
        "```\n",
        "(tensor([[1.8542],\n",
        "         [1.9611],\n",
        "         [2.2884],\n",
        "         [3.0481],\n",
        "         [1.7067],\n",
        "         [2.5290],\n",
        "         [1.7989]]), torch.Size([7, 1]))\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 48,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "D-lOWI_1jRMm",
        "outputId": "2a2f5743-e30b-478e-93d2-a4c77b77f63f"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(tensor([[1.5985],\n",
              "         [1.1173],\n",
              "         [1.2741],\n",
              "         [1.6838],\n",
              "         [0.8279],\n",
              "         [1.0347],\n",
              "         [1.2498]]),\n",
              " torch.Size([7, 1]),\n",
              " device(type='cpu'))"
            ]
          },
          "execution_count": 48,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "import torch\n",
        "\n",
        "# Set manual seed\n",
        "RANDOM_SEED=0\n",
        "\n",
        "# Create two random tensors\n",
        "torch.manual_seed(RANDOM_SEED)\n",
        "rand_tensor_A = torch.rand(7,7)\n",
        "\n",
        "torch.manual_seed(RANDOM_SEED)\n",
        "rand_tensor_B = torch.rand(1,7)\n",
        "\n",
        "# Matrix multiply tensors\n",
        "mat_mul_res = rand_tensor_A.matmul(rand_tensor_B.T)\n",
        "mat_mul_res, mat_mul_res.size(), mat_mul_res.device"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ezY6ks9Cis37"
      },
      "source": [
        "### 5. Speaking of random seeds, we saw how to set it with `torch.manual_seed()` but is there a GPU equivalent? (hint: you'll need to look into the documentation for `torch.cuda` for this one)\n",
        "  * If there is, set the GPU random seed to `1234`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 51,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_LKWcfSTjp00",
        "outputId": "80ece8f3-4bcb-4466-9ac9-4432b9291e9b"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(tensor([[0.6130, 0.0101],\n",
              "         [0.3984, 0.0403],\n",
              "         [0.1563, 0.4825],\n",
              "         [0.7362, 0.4060]], device='cuda:0'),\n",
              " device(type='cuda', index=0),\n",
              " torch.float32)"
            ]
          },
          "execution_count": 51,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Set random seed on the GPU\n",
        "device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
        "\n",
        "\n",
        "CUDA_RANDOM_SEED = 42\n",
        "torch.cuda.manual_seed(CUDA_RANDOM_SEED)\n",
        "gpu_tensor = torch.rand(4,2, device=device)\n",
        "gpu_tensor, gpu_tensor.device, gpu_tensor.dtype"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ir9qSaj6it4n"
      },
      "source": [
        "\n",
        "### 6. Create two random tensors of shape `(2, 3)` and send them both to the GPU (you'll need access to a GPU for this). Set `torch.manual_seed(1234)` when creating the tensors (this doesn't have to be the GPU random seed). The output should be something like:\n",
        "\n",
        "```\n",
        "Device: cuda\n",
        "(tensor([[0.0290, 0.4019, 0.2598],\n",
        "         [0.3666, 0.0583, 0.7006]], device='cuda:0'),\n",
        " tensor([[0.0518, 0.4681, 0.6738],\n",
        "         [0.3315, 0.7837, 0.5631]], device='cuda:0'))\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 75,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "azXExiFZj5nm",
        "outputId": "347f9e7b-a4fe-4c21-bfc3-35891a966ed4"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "tensor_A:\n",
            " tensor([[0.0290, 0.4019, 0.2598],\n",
            "        [0.3666, 0.0583, 0.7006]]), \n",
            "Size:\t torch.Size([2, 3]), \n",
            "Device:\t cpu\n",
            "\n",
            "\n",
            "tensor_B:\n",
            " tensor([[0.0290, 0.4019, 0.2598],\n",
            "        [0.3666, 0.0583, 0.7006]]), \n",
            "Size:\t torch.Size([2, 3]), \n",
            "Device:\t cpu\n",
            "\n",
            "\n",
            "---------------------------------------------------------------------------------------------------\n",
            "tensor_A_on_gpu:\n",
            " tensor([[0.0290, 0.4019, 0.2598],\n",
            "        [0.3666, 0.0583, 0.7006]], device='cuda:0'), \n",
            "Size:\t torch.Size([2, 3]), \n",
            "Device:\t cuda:0\n",
            "\n",
            "\n",
            "tensor_B_on_gpu:\n",
            " tensor([[0.0290, 0.4019, 0.2598],\n",
            "        [0.3666, 0.0583, 0.7006]], device='cuda:0'), \n",
            "Size:\t torch.Size([2, 3]), \n",
            "Device:\t cuda:0\n",
            "\n",
            "\n",
            "---------------------------------------------------------------------------------------------------\n"
          ]
        }
      ],
      "source": [
        "import torch\n",
        "\n",
        "# Set random seed\n",
        "RANDOM_SEED=1234\n",
        "\n",
        "torch.manual_seed(RANDOM_SEED)\n",
        "tensor_A = torch.rand(2,3)\n",
        "\n",
        "torch.manual_seed(RANDOM_SEED)\n",
        "tensor_B = torch.rand(2,3)\n",
        "\n",
        "print(f\"tensor_A:\\n {tensor_A}, \\nSize:\\t {tensor_A.shape}, \\nDevice:\\t {tensor_A.device}\\n\\n\")\n",
        "print(f\"tensor_B:\\n {tensor_A}, \\nSize:\\t {tensor_A.shape}, \\nDevice:\\t {tensor_A.device}\\n\\n\")\n",
        "\n",
        "print(\"---------------------------------------------------------------------------------------------------\")\n",
        "\n",
        "# Check for access to GPU\n",
        "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
        "\n",
        "# Create two random tensors on GPU\n",
        "# tensor_A_on_gpu = torch.rand((2,3), device=device)\n",
        "# tensor_B_on_gpu = torch.rand((2,3), device=device)\n",
        "tensor_A_on_gpu = tensor_A.to(device)\n",
        "tensor_B_on_gpu = tensor_B.to(device)\n",
        "\n",
        "print(f\"tensor_A_on_gpu:\\n {tensor_A_on_gpu}, \\nSize:\\t {tensor_A_on_gpu.shape}, \\nDevice:\\t {tensor_A_on_gpu.device}\\n\\n\")\n",
        "print(f\"tensor_B_on_gpu:\\n {tensor_B_on_gpu}, \\nSize:\\t {tensor_B_on_gpu.shape}, \\nDevice:\\t {tensor_B_on_gpu.device}\\n\\n\")\n",
        "\n",
        "print(\"---------------------------------------------------------------------------------------------------\")\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5TlAxeiSiu1y"
      },
      "source": [
        "\n",
        "### 7. Perform a matrix multiplication on the tensors you created in 6 (again, you may have to adjust the shapes of one of the tensors).\n",
        "\n",
        "The output should look like:\n",
        "```\n",
        "(tensor([[0.3647, 0.4709],\n",
        "         [0.5184, 0.5617]], device='cuda:0'), torch.Size([2, 2]))\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 70,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fAeG7ox0lHEO",
        "outputId": "5567c3eb-a8e5-46bd-c8e1-23de2eb21d58"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([[1.7622, 1.4337],\n",
              "        [1.4337, 1.4338]])"
            ]
          },
          "execution_count": 70,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Perform matmul on tensor_A and tensor_B\n",
        "res_mul = tensor_A.matmul(tensor_B.T)\n",
        "res_mul"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G7qfa5CSivwg"
      },
      "source": [
        "### 8. Find the maximum and minimum values of the output of 7."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 73,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Fu8_3mZpllOd",
        "outputId": "a76364d8-ed66-42ad-dce3-a1c09afcb714"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "tensor(1.7622)\n",
            "tensor(1.4337)\n",
            "Maximum : 1.7622159719467163\n",
            "Minimum : 1.4336886405944824\n"
          ]
        }
      ],
      "source": [
        "# Find max\n",
        "print(f\"Maximum : {res_mul.max()}\")\n",
        "\n",
        "# Find min\n",
        "print(f\"Minimum : {res_mul.min()}\")\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wrTj5FgNiw47"
      },
      "source": [
        "### 9. Find the maximum and minimum index values of the output of 7."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 79,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CCEKt4K2lsfQ",
        "outputId": "c468e74d-15c8-4ef1-ad59-ffe8b6663256"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "The position of maximum 1.7622159719467163 is : 0\n",
            "The position of minimum 1.4336886405944824 is : 1\n"
          ]
        }
      ],
      "source": [
        "# Find arg max\n",
        "print(f\"The position of maximum {res_mul.max()} is : {res_mul.argmax()}\")\n",
        "\n",
        "# Find arg min\n",
        "print(f\"The position of minimum {res_mul.min()} is : {res_mul.argmin()}\")\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hmeybz4uixy7"
      },
      "source": [
        "\n",
        "### 10. Make a random tensor with shape `(1, 1, 1, 10)` and then create a new tensor with all the `1` dimensions removed to be left with a tensor of shape `(10)`. Set the seed to `7` when you create it and print out the first tensor and it's shape as well as the second tensor and it's shape.\n",
        "\n",
        "The output should look like:\n",
        "\n",
        "```\n",
        "tensor([[[[0.5349, 0.1988, 0.6592, 0.6569, 0.2328, 0.4251, 0.2071, 0.6297,\n",
        "           0.3653, 0.8513]]]]) torch.Size([1, 1, 1, 10])\n",
        "tensor([0.5349, 0.1988, 0.6592, 0.6569, 0.2328, 0.4251, 0.2071, 0.6297, 0.3653,\n",
        "        0.8513]) torch.Size([10])\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 92,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TQ9zbRzVl1jV",
        "outputId": "83a85842-b8af-4dfc-ee5a-4b7d16c98947"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "rand_tensor : \n",
            " tensor([[[[0.0290, 0.4019, 0.2598, 0.3666, 0.0583, 0.7006, 0.0518, 0.4681,\n",
            "           0.6738, 0.3315]]]])\n",
            "Size :\t torch.Size([1, 1, 1, 10])\n",
            "\n",
            "---------------------------------------------------\n",
            "\n",
            "rand_tensor_squeezed : \n",
            " tensor([0.0290, 0.4019, 0.2598, 0.3666, 0.0583, 0.7006, 0.0518, 0.4681, 0.6738,\n",
            "        0.3315])\n",
            "Size :\t torch.Size([10])\n"
          ]
        }
      ],
      "source": [
        "# Set seed\n",
        "RANDOM_SEDD = 7\n",
        "\n",
        "\n",
        "\n",
        "# Create random tensor\n",
        "torch.manual_seed(RANDOM_SEED)\n",
        "rand_tensor = torch.rand(1, 1, 1, 10)\n",
        "print(f\"rand_tensor : \\n {rand_tensor}\")\n",
        "print(f\"Size :\\t {rand_tensor.shape}\")\n",
        "# print(f\"Device :\\t {rand_tensor.device}\")\n",
        "\n",
        "# torch.manual_seed(RANDOM_SEED)\n",
        "print(\"\\n---------------------------------------------------\\n\")\n",
        "\n",
        "# Remove single dimensions\n",
        "rand_tensor_squeezed = rand_tensor.squeeze()\n",
        "print(f\"rand_tensor_squeezed : \\n {rand_tensor_squeezed}\")\n",
        "print(f\"Size :\\t {rand_tensor_squeezed.shape}\")\n",
        "# print(f\"Device :\\t {rand_tensor_squeezed.device}\")\n",
        "\n",
        "\n",
        "# Print out tensors and their shapes\n"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "include_colab_link": true,
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python",
      "version": "3.11.6"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}