00_PyTorch_Fundamentals_Exercises.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# Exercises"
      ],
      "metadata": {
        "id": "JYsG56_TSwi2"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 1. Documentation reading\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",
        "\n",
        "* The documentation on [`torch.Tensor`](https://pytorch.org/docs/stable/tensors.html)\n",
        "* The documentation on [`torch.cuda`](https://pytorch.org/docs/stable/cuda.html)"
      ],
      "metadata": {
        "id": "inVZ-P9iSqui"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch"
      ],
      "metadata": {
        "id": "h6HOaM8IrM34"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# default float datatype is `float32`\n",
        "\n",
        "default_float_datatype_tensor = torch.tensor([0.5, 0.1, 0.7, 0.3])\n",
        "default_float_datatype_tensor, default_float_datatype_tensor.dtype"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "B5HR5iD30MoK",
        "outputId": "ccbeff41-f7ae-4afa-85d6-22012d1d72fe"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor([0.5000, 0.1000, 0.7000, 0.3000]), torch.float32)"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vC3I0vLQM0Km",
        "outputId": "7cf2e857-28ff-4419-b1d7-bb107704a5ba"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor([4., 7., 8.]), torch.float32)"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ],
      "source": [
        "# torch.Tensor\n",
        "\n",
        "## Data Types\n",
        "\n",
        "# float32 datatype\n",
        "# create tensor\n",
        "float_32_tensor = torch.tensor([4, 7, 8], dtype=torch.float) # `torch.float` or, `torch.float32`\n",
        "float_32_tensor, float_32_tensor.dtype"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "float_32Tensor = torch.tensor([1, 2, 3], dtype=torch.float32)\n",
        "float_32Tensor"
      ],
      "metadata": {
        "id": "BaWDfSYyUE8u",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "82244bf4-b9dc-4fc4-d9ff-08bd721abf75"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([1., 2., 3.])"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# float64 datatype\n",
        "float_64_tensor = torch.tensor([1, 4, 2], dtype=torch.float64) # `torch.float64` or, `torch.double`\n",
        "float_64_tensor, float_64_tensor.dtype"
      ],
      "metadata": {
        "id": "-HGbyZzVtBRf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3c6c35ab-e8c5-4e2b-d356-1894654fdf93"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor([1., 4., 2.], dtype=torch.float64), torch.float64)"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "float_64Tensor = torch.tensor([6, 9, 2], dtype=torch.double)\n",
        "float_64Tensor, float_64Tensor.dtype"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zXJ_xdZxBxn5",
        "outputId": "0ce04d4c-1ae4-40fd-dfa0-06c8fbd41271"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor([6., 9., 2.], dtype=torch.float64), torch.float64)"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "1. Sometimes referred to as binary16: uses 1 sign, 5 exponent, and 10 significand bits. Useful when precision is important at the expense of range.\n",
        "'''\n",
        "\n",
        "# 1. float16 datatype\n",
        "float_16_tensor = torch.tensor([7, 3, 4], dtype=torch.float16)\n",
        "float_16_tensor, float_16_tensor.dtype"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9WyXy3ozCB3k",
        "outputId": "13ffd745-afba-4c75-97e0-274a7926cd28"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor([7., 3., 4.], dtype=torch.float16), torch.float16)"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#\n",
        "float_16Tensor = torch.tensor([8, 2, 6], dtype=torch.half)\n",
        "float_16Tensor, float_16Tensor.dtype"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gwZM33lZDkTo",
        "outputId": "7749c3a7-0485-4b0d-f49c-d981f62bea3e"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor([8., 2., 6.], dtype=torch.float16), torch.float16)"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "Sometimes referred to as Brain Floating Point: uses 1 sign, 8 exponent, and 7 significand bits. Useful when range is important, since it has the same number of exponent bits as float32\n",
        "'''\n",
        "\n",
        "# 2. float16 datatype\n",
        "float_16_tensor = torch.tensor([7, 3, 4], dtype=torch.bfloat16)\n",
        "float_16_tensor, float_16_tensor.dtype"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LwY1f2rD3cFy",
        "outputId": "1799e63a-5ed7-45fb-ee63-c17b08d818f6"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor([7., 3., 4.], dtype=torch.bfloat16), torch.bfloat16)"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# default integer datatype is `int64`\n",
        "default_int_datatype_tensor = torch.tensor([6,1,9])\n",
        "default_int_datatype_tensor, default_int_datatype_tensor.dtype"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TS5Agqo90qFc",
        "outputId": "fe94602b-dbe0-407b-cf8f-218d6245a1ab"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor([6, 1, 9]), torch.int64)"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# integers(signed) datatypes\n",
        "int_8_tensor = torch.tensor([4,8,1], dtype=torch.int8)\n",
        "int_8_tensor, int_8_tensor.dtype"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AfE3G02FJt25",
        "outputId": "9eaf064b-0178-40e8-f3ff-38c6f3707c66"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor([4, 8, 1], dtype=torch.int8), torch.int8)"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "int_16_tensor = torch.tensor([6,8,2], dtype=torch.int16)\n",
        "int_16_tensor, int_16_tensor.dtype"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Hq8BQ0nunhua",
        "outputId": "6389766d-7159-46ba-b869-33ef31a59cf7"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor([6, 8, 2], dtype=torch.int16), torch.int16)"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "int_16_or_short_tensor = torch.tensor([7,1,9], dtype=torch.short)\n",
        "int_16_or_short_tensor, int_16_or_short_tensor.dtype"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZLtd9T0Ln7L0",
        "outputId": "d2858691-6912-4db1-f7b7-aebbc6654b9d"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor([7, 1, 9], dtype=torch.int16), torch.int16)"
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 32bit integers (signed)\n",
        "int_32_tensor = torch.tensor([6,3,9], dtype=torch.int32)\n",
        "int_32_tensor, int_32_tensor.dtype"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tB9sT2atoRr8",
        "outputId": "06e45b90-a4f9-44bc-ce2a-9a276ab30f02"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor([6, 3, 9], dtype=torch.int32), torch.int32)"
            ]
          },
          "metadata": {},
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "int32Tensor = torch.tensor([6,1,9], dtype=torch.int)\n",
        "int32Tensor, int32Tensor.dtype"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IyFrWjq_p25L",
        "outputId": "280e7447-916b-4cf0-e6b3-8afa2f525442"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor([6, 1, 9], dtype=torch.int32), torch.int32)"
            ]
          },
          "metadata": {},
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "int_64_Tensor = torch.tensor([7,1,8], dtype=torch.int64)\n",
        "int_64_Tensor, int_64_Tensor.dtype"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3isl2Uo7zE8y",
        "outputId": "e3f1f0f4-63a5-44b1-c86e-81f65d02757f"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor([7, 1, 8]), torch.int64)"
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "int_64_or_long_Tensor = torch.tensor([7,1,8], dtype=torch.long)\n",
        "int_64_or_long_Tensor, int_64_or_long_Tensor.dtype"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4rOd-2FHzTeU",
        "outputId": "28304d90-33eb-4693-aab0-3777d37c43ca"
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor([7, 1, 8]), torch.int64)"
            ]
          },
          "metadata": {},
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# boolean datatype\n",
        "boolean_tensor = torch.tensor([1,0,1,0,1], dtype=torch.bool)\n",
        "boolean_tensor, boolean_tensor.dtype"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "614MUQ9Czu1L",
        "outputId": "d208283d-e76f-4e15-fa0a-a8bbb2539bfb"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor([ True, False,  True, False,  True]), torch.bool)"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "## backward compatibility\n",
        "# 32-bit floating point\n",
        "x = torch.FloatTensor([1,8,5])\n",
        "x, x.dtype"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XjbMp9an1jTz",
        "outputId": "c4172855-426a-4dc2-b450-743bc69657fe"
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor([1., 8., 5.]), torch.float32)"
            ]
          },
          "metadata": {},
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# converting datatype (float32 to float64)\n",
        "\n",
        "# 1.\n",
        "y = x.type(torch.DoubleTensor)\n",
        "y, y.dtype"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XVwVm8bU-dwc",
        "outputId": "77d15a58-886b-436a-e826-eac91d3116db"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor([1., 8., 5.], dtype=torch.float64), torch.float64)"
            ]
          },
          "metadata": {},
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 2.\n",
        "z = x.type(torch.float64)\n",
        "z, z.dtype"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BMapolzt_bu0",
        "outputId": "e22a8ebf-a29b-4bc4-99ae-4be58b4ea18c"
      },
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor([1., 8., 5.], dtype=torch.float64), torch.float64)"
            ]
          },
          "metadata": {},
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 3.\n",
        "w = x.type(torch.double)\n",
        "w, w.dtype"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_cxej9T5A_L9",
        "outputId": "8bc42ea8-77eb-42e6-cc86-626d25fcd0d3"
      },
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor([1., 8., 5.], dtype=torch.float64), torch.float64)"
            ]
          },
          "metadata": {},
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 64-bit floating point\n",
        "a = torch.DoubleTensor([7,1,5,4])\n",
        "a"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cj6sKOzQBIpL",
        "outputId": "413f9e86-e842-42c6-f249-97253ebeb8f8"
      },
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([7., 1., 5., 4.], dtype=torch.float64)"
            ]
          },
          "metadata": {},
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 16-bit floating point\n",
        "b = torch.HalfTensor([4,7,1])\n",
        "b"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0vNc6rbYBaMy",
        "outputId": "6d961c92-fff2-446e-b344-d6f3b648a13c"
      },
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([4., 7., 1.], dtype=torch.float16)"
            ]
          },
          "metadata": {},
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 16-bit floating point\n",
        "c = torch.BFloat16Tensor([5,8,4])\n",
        "c"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UFpeT5I6Baiu",
        "outputId": "541ea179-3eab-447e-8581-a9512feeeeeb"
      },
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([5., 8., 4.], dtype=torch.bfloat16)"
            ]
          },
          "metadata": {},
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 8-bit integer (unsigned)\n",
        "d = torch.ByteTensor([1,2,3])\n",
        "d"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aHD3TuGjBat0",
        "outputId": "961e0b53-026e-4d9e-fe0f-b0a91aefcef4"
      },
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([1, 2, 3], dtype=torch.uint8)"
            ]
          },
          "metadata": {},
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 8-bit integer (signed)\n",
        "e = torch.CharTensor([3,5,4])\n",
        "e"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8yScJemeBbnU",
        "outputId": "88ab206c-1a4a-4197-f33c-26158c50ef66"
      },
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([3, 5, 4], dtype=torch.int8)"
            ]
          },
          "metadata": {},
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 16-bit integer (signed)\n",
        "f = torch.ShortTensor([5,7,9])\n",
        "f"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Rr02mupzBhTc",
        "outputId": "08b9c87d-cbc8-4fe7-e615-9897cfb1d595"
      },
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([5, 7, 9], dtype=torch.int16)"
            ]
          },
          "metadata": {},
          "execution_count": 29
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 32-bit integer (signed)\n",
        "g = torch.IntTensor([6,1,5])\n",
        "g"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LRDbjRd2BiaL",
        "outputId": "1558ef77-8939-4aec-d56c-bcd1fde0462e"
      },
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([6, 1, 5], dtype=torch.int32)"
            ]
          },
          "metadata": {},
          "execution_count": 30
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 64-bit integer (signed)\n",
        "h = torch.LongTensor([5,2,9])\n",
        "h"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FB2N2KCIBi7X",
        "outputId": "fb64627e-9be8-4ecf-b26c-164e71b954ea"
      },
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([5, 2, 9])"
            ]
          },
          "metadata": {},
          "execution_count": 31
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Boolean\n",
        "i = torch.BoolTensor([0,1,0])\n",
        "i, i.dtype"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "42xDhOOTBzYL",
        "outputId": "e6b0a4c1-a808-429b-a151-21847ac1fef0"
      },
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor([False,  True, False]), torch.bool)"
            ]
          },
          "metadata": {},
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# factory function - `torch.empty()`\n",
        "k = torch.empty(size=(3,3),dtype=torch.float16)\n",
        "k, k.ndim, k.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "j1PwGiskEdDv",
        "outputId": "beaf1763-4fcc-4c9d-e6bb-2b6938f8044c"
      },
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor([[ 2.7660e+03,  1.3900e+03,  7.6660e-01],\n",
              "         [ 1.1963e-02,  6.7353e-06,  0.0000e+00],\n",
              "         [ 0.0000e+00,  0.0000e+00, -4.4556e-03]], dtype=torch.float16),\n",
              " 2,\n",
              " torch.Size([3, 3]))"
            ]
          },
          "metadata": {},
          "execution_count": 33
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# initializing and basic operations\n",
        "m = torch.tensor([\n",
        "    [1., -1.],\n",
        "    [1., -1.]\n",
        "])\n",
        "m"
      ],
      "metadata": {
        "id": "Num9gyO7FeiF",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3f141157-7f8c-42d8-d5d2-12cfa8a6a0ad"
      },
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[ 1., -1.],\n",
              "        [ 1., -1.]])"
            ]
          },
          "metadata": {},
          "execution_count": 34
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "from_numpy = torch.tensor(\n",
        "    np.array([\n",
        "        [1, 2, 3],\n",
        "        [4, 5, 6]\n",
        "    ])\n",
        ")\n",
        "from_numpy"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cq7xtS69kiaH",
        "outputId": "f2e1759b-0610-4a08-cf9d-f9c270d5ec64"
      },
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[1, 2, 3],\n",
              "        [4, 5, 6]])"
            ]
          },
          "metadata": {},
          "execution_count": 35
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "check = torch.tensor([1, 2, 3], dtype=torch.float16)\n",
        "check.requires_grad_()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fSQP13Otk282",
        "outputId": "88e96042-f4a7-46d8-fc39-a39cf825425b"
      },
      "execution_count": 36,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([1., 2., 3.], dtype=torch.float16, requires_grad=True)"
            ]
          },
          "metadata": {},
          "execution_count": 36
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# another method\n",
        "check2 = torch.tensor([1.0, 4.1, 9.2])\n",
        "check2.detach_(), check2.dtype"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VGL32mgcldOG",
        "outputId": "3315784c-baf1-4ed4-94c6-32b19474c1eb"
      },
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor([1.0000, 4.1000, 9.2000]), torch.float32)"
            ]
          },
          "metadata": {},
          "execution_count": 37
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "y = torch.tensor(check2) # To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
        "y"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qDjThkgql7JW",
        "outputId": "ccc0233d-419c-4c41-f88a-11588fb4dbc9"
      },
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-38-94b980d24cc2>:1: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
            "  y = torch.tensor(check2) # To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([1.0000, 4.1000, 9.2000])"
            ]
          },
          "metadata": {},
          "execution_count": 38
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#\n",
        "TENSOR_X = torch.tensor([2.1, 6.4, 3.9], requires_grad=True)\n",
        "\n",
        "TENSOR_Y = TENSOR_X.detach()\n",
        "\n",
        "TENSOR_Y.requires_grad_()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jXImePCwmzf3",
        "outputId": "747162a9-1da0-48bd-e5e6-890bd555b2fc"
      },
      "execution_count": 39,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([2.1000, 6.4000, 3.9000], requires_grad=True)"
            ]
          },
          "metadata": {},
          "execution_count": 39
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "checkTensor = torch.Tensor([1, 2, 3])\n",
        "checkTensor, checkTensor.dtype"
      ],
      "metadata": {
        "id": "1IY6bYx3oBBV",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c8cc3b9e-ae42-4e86-87a0-b92050073809"
      },
      "execution_count": 40,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor([1., 2., 3.]), torch.float32)"
            ]
          },
          "metadata": {},
          "execution_count": 40
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Tensor class reference\n",
        "```\n",
        "class     torch.Tensor\n",
        "```\n",
        "There are a few main ways to create a tensor, depending on your use case.\n",
        "\n",
        "1. To create a tensor with pre-existing data, use `torch.tensor()`.\n",
        "\n",
        "2. To create a tensor with specific size, use `torch.*` tensor creation ops (see [Creation Ops](https://pytorch.org/docs/stable/torch.html#tensor-creation-ops)).\n",
        "\n",
        "3. To create a tensor with the same size (and similar types) as another tensor, use `torch.*_like` tensor creation ops (see [Creation Ops](https://pytorch.org/docs/stable/torch.html#tensor-creation-ops)).\n",
        "\n",
        "4. To create a tensor with similar type but different size as another tensor, use `tensor.new_*` creation ops.\n",
        "\n"
      ],
      "metadata": {
        "id": "br0TuEbJEnMl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# 1\n",
        "first_tensor = torch.tensor([6, 3, 2])\n",
        "first_tensor"
      ],
      "metadata": {
        "id": "BHis4qVmpvJs",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "41af1fc1-65b3-4cef-fefc-f80b13d61919"
      },
      "execution_count": 41,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([6, 3, 2])"
            ]
          },
          "metadata": {},
          "execution_count": 41
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 2 torch.*\n",
        "\n",
        "# 2.1 - torch.zeros(dimension or size)\n",
        "second_tensor = torch.zeros(3, 4)\n",
        "second_tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "roO6smUwFT6S",
        "outputId": "30e269da-79b1-4b93-9c66-755345046f66"
      },
      "execution_count": 42,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[0., 0., 0., 0.],\n",
              "        [0., 0., 0., 0.],\n",
              "        [0., 0., 0., 0.]])"
            ]
          },
          "metadata": {},
          "execution_count": 42
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 2.2 torch.zeros_like(source_tensor)\n",
        "source_tensor = torch.tensor([[3, 4, 6], [1, 8, 3]])\n",
        "\n",
        "third_tensor = torch.zeros_like(source_tensor)\n",
        "third_tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PJkW2xOLHm2J",
        "outputId": "d5e3ddbc-75fe-4d36-861f-5fbbf523ec33"
      },
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[0, 0, 0],\n",
              "        [0, 0, 0]])"
            ]
          },
          "metadata": {},
          "execution_count": 43
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 2.3 torch.ones(dimension)\n",
        "ones_tensor = torch.ones(5,8)\n",
        "ones_tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lxnTlCLkmjfV",
        "outputId": "5dc763dd-52ba-4b9b-9c0f-04cfe9226901"
      },
      "execution_count": 44,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[1., 1., 1., 1., 1., 1., 1., 1.],\n",
              "        [1., 1., 1., 1., 1., 1., 1., 1.],\n",
              "        [1., 1., 1., 1., 1., 1., 1., 1.],\n",
              "        [1., 1., 1., 1., 1., 1., 1., 1.],\n",
              "        [1., 1., 1., 1., 1., 1., 1., 1.]])"
            ]
          },
          "metadata": {},
          "execution_count": 44
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 2.4 torch.ones_like(source_tensor)\n",
        "source_tensor = torch.tensor([[3, 6, 7], [9,5,8]])\n",
        "ones_like_tensor = torch.ones_like(source_tensor)\n",
        "print(f\"source_tensor = \\n{source_tensor}\")\n",
        "print(f\"ones_like_tensor = \\n{ones_like_tensor}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PMY0YzwEo0KB",
        "outputId": "971e41bf-d9c7-43fb-a19e-d368acb7c0a8"
      },
      "execution_count": 45,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "source_tensor = \n",
            "tensor([[3, 6, 7],\n",
            "        [9, 5, 8]])\n",
            "ones_like_tensor = \n",
            "tensor([[1, 1, 1],\n",
            "        [1, 1, 1]])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 2.5 torch.arange(start, end, step) - returns a 1-D tensor of size [end - start / step]\n",
        "arange_tensor = torch.arange(1, 15, 2)\n",
        "arange_tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-FpJIdLmo4Im",
        "outputId": "f340b254-4313-421c-ef20-315cbf0e6bdb"
      },
      "execution_count": 46,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([ 1,  3,  5,  7,  9, 11, 13])"
            ]
          },
          "metadata": {},
          "execution_count": 46
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 2.6 torch.linspace(start, end, step) - Creates a one-dimensional tensor of size steps whose values are evenly spaced from start to end, inclusive.\n",
        "linspace_tensor = torch.linspace(60, 100, 14)\n",
        "linspace_tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hJ2hpBIGpFt2",
        "outputId": "300e5437-d5e5-444d-ff80-425cd6681c44"
      },
      "execution_count": 47,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([ 60.0000,  63.0769,  66.1538,  69.2308,  72.3077,  75.3846,  78.4615,\n",
              "         81.5385,  84.6154,  87.6923,  90.7692,  93.8462,  96.9231, 100.0000])"
            ]
          },
          "metadata": {},
          "execution_count": 47
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 2.7 torch.logspace(start, end, step, base) - Creates a one-dimensional tensor of size steps whose values are evenly spaced from base start base_start to base_end base end, inclusive, on a logarithmic scale with base base.\n",
        "logspace_tensor = torch.logspace(3, 9, 5) # by default base=10.0\n",
        "logspace_tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-arR1AKnpG7Y",
        "outputId": "737bcc77-41d4-48d7-8eb3-7ca8fc5c53c8"
      },
      "execution_count": 48,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([1.0000e+03, 3.1623e+04, 1.0000e+06, 3.1623e+07, 1.0000e+09])"
            ]
          },
          "metadata": {},
          "execution_count": 48
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "calculation for getting the values of the return Tensor,\n",
        "value = base ** (start + i * (end-start) / (steps-1)),   where `i` is the index of the value in the sequence, ranging from 0 to `steps-1`\n",
        "'''\n",
        "\n",
        "logspace_tensor = torch.logspace(0, 2, 10)\n",
        "logspace_tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oT4GEVIzpHWb",
        "outputId": "a7e345cf-0a9b-4d03-db0d-39e3e24b28f1"
      },
      "execution_count": 49,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([  1.0000,   1.6681,   2.7826,   4.6416,   7.7426,  12.9155,  21.5443,\n",
              "         35.9381,  59.9484, 100.0000])"
            ]
          },
          "metadata": {},
          "execution_count": 49
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "exploring_logspace = torch.logspace(start=0.1, end=1.0, steps=1)\n",
        "exploring_logspace"
      ],
      "metadata": {
        "id": "eS9AgMYopHqP",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "187e97e6-2435-4099-a9fd-9c7f0b80067d"
      },
      "execution_count": 50,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([1.2589])"
            ]
          },
          "metadata": {},
          "execution_count": 50
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "exploring_logspace = torch.logspace(start=0.1, end=1.0, steps=2)\n",
        "exploring_logspace"
      ],
      "metadata": {
        "id": "GZIwFxC-pH8Y",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a3243d5e-f968-457c-95d7-73c0677076c3"
      },
      "execution_count": 51,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([ 1.2589, 10.0000])"
            ]
          },
          "metadata": {},
          "execution_count": 51
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "exploring_logspace = torch.logspace(start=0.1, end=1.0, steps=3)\n",
        "exploring_logspace"
      ],
      "metadata": {
        "id": "dXIcI7nzpINW",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "81d02562-767b-4d43-fb1c-a4b2807ae7ba"
      },
      "execution_count": 52,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([ 1.2589,  3.5481, 10.0000])"
            ]
          },
          "metadata": {},
          "execution_count": 52
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "exploring_logspace = torch.logspace(start=0.1, end=1.0, steps=4)\n",
        "exploring_logspace"
      ],
      "metadata": {
        "id": "pJ5QFJi2pImF",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4e06dc81-4f2d-4868-9992-3fbdb82771c0"
      },
      "execution_count": 53,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([ 1.2589,  2.5119,  5.0119, 10.0000])"
            ]
          },
          "metadata": {},
          "execution_count": 53
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "exploring_logspace = torch.logspace(start=0.1, end=1.0, steps=5)\n",
        "exploring_logspace"
      ],
      "metadata": {
        "id": "8eOrZGTfpJL5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "beb355ab-1c49-44fd-d08e-433ab3258243"
      },
      "execution_count": 54,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([ 1.2589,  2.1135,  3.5481,  5.9566, 10.0000])"
            ]
          },
          "metadata": {},
          "execution_count": 54
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "calculation of `torch.logspace(start=0.1, end=1.0, steps=10)`\n",
        "\n",
        "values of the return tensor are:\n",
        "\n",
        "1st_value  = base ** (start + (steps - 10) * (end - start / steps - 1)) [equivalent of (base ** start), if you put those values in the equation you will understand why it's equivalent with `base ** start`]\n",
        "2nd_value  = base ** (start + (steps - 9) * (end - start / steps - 1))\n",
        "3rd_value  = base ** (start + (steps - 8) * (end - start / steps - 1))\n",
        "4th_value  = base ** (start + (steps - 7) * (end - start / steps - 1))\n",
        "5th_value  = base ** (start + (steps - 6) * (end - start / steps - 1))\n",
        "6th_value  = base ** (start + (steps - 5) * (end - start / steps - 1))\n",
        "7th_value  = base ** (start + (steps - 4) * (end - start / steps - 1))\n",
        "6th_value  = base ** (start + (steps - 3) * (end - start / steps - 1))\n",
        "8th_value  = base ** (start + (steps - 2) * (end - start / steps - 1))\n",
        "10th_value = base ** (start + (steps - 1) * (end - start / steps - 1)) [equivalent of (base ** end), if you put those values in the equation you will understand why it's equivalent with `base ** end`]\n",
        "\n",
        "notice: for user defined purposes if we mention `i` instead of (steps - 10, 9, 8, 7, 6, 5, 4, 3, 2, 1) that means the index of the `i` will be start `0` to `steps - 1`\n",
        "        as for this example 0 to 9 because `steps = 10`\n",
        "\n",
        "source: https://pytorch.org/docs/stable/generated/torch.logspace.html#torch.logspace\n",
        "'''\n",
        "\n",
        "\n",
        "exploring_logspace = torch.logspace(start=0.1, end=1.0, steps=10)\n",
        "exploring_logspace"
      ],
      "metadata": {
        "id": "2X6TwoGvpJrN",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "16fa4e71-1c6b-462b-a723-01aab9dc51dd"
      },
      "execution_count": 55,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([ 1.2589,  1.5849,  1.9953,  2.5119,  3.1623,  3.9811,  5.0119,  6.3096,\n",
              "         7.9433, 10.0000])"
            ]
          },
          "metadata": {},
          "execution_count": 55
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 2.8 torch.eye() -> Returns a 2-D tensor with ones on the diagonal and zeros elsewhere.\n",
        "eye_tensor = torch.eye(5) # paramers of eye() are, 1. n (which will be a int number) -> the number of rows 2. m (which will be a int number) -> the number of columns with default being n\n",
        "eye_tensor, eye_tensor.shape, eye_tensor.ndim"
      ],
      "metadata": {
        "id": "GEMQPVQpVJ_Z",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "78649f7a-7c02-448c-c0bf-2ec156142e25"
      },
      "execution_count": 56,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor([[1., 0., 0., 0., 0.],\n",
              "         [0., 1., 0., 0., 0.],\n",
              "         [0., 0., 1., 0., 0.],\n",
              "         [0., 0., 0., 1., 0.],\n",
              "         [0., 0., 0., 0., 1.]]),\n",
              " torch.Size([5, 5]),\n",
              " 2)"
            ]
          },
          "metadata": {},
          "execution_count": 56
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "eye_tensor = torch.eye(8, 8)\n",
        "eye_tensor, eye_tensor.shape, eye_tensor.ndim"
      ],
      "metadata": {
        "id": "6aQLYMiAVKDO",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "60dec906-6bdc-4684-d803-c3bf1e7ddaf5"
      },
      "execution_count": 57,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor([[1., 0., 0., 0., 0., 0., 0., 0.],\n",
              "         [0., 1., 0., 0., 0., 0., 0., 0.],\n",
              "         [0., 0., 1., 0., 0., 0., 0., 0.],\n",
              "         [0., 0., 0., 1., 0., 0., 0., 0.],\n",
              "         [0., 0., 0., 0., 1., 0., 0., 0.],\n",
              "         [0., 0., 0., 0., 0., 1., 0., 0.],\n",
              "         [0., 0., 0., 0., 0., 0., 1., 0.],\n",
              "         [0., 0., 0., 0., 0., 0., 0., 1.]]),\n",
              " torch.Size([8, 8]),\n",
              " 2)"
            ]
          },
          "metadata": {},
          "execution_count": 57
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 2.9 - torch.empty(size of the tensor) -> Return a tensor filled with uninitialized data.\n",
        "empty_tensor = torch.empty((3, 4))\n",
        "empty_tensor"
      ],
      "metadata": {
        "id": "XeMzeyslVKIz",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ffd8fb97-9cdc-4676-cf5d-f5f4ee189827"
      },
      "execution_count": 58,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[3.9765e+03, 3.2924e-41, 0.0000e+00, 0.0000e+00],\n",
              "        [1.4013e-45, 0.0000e+00, 0.0000e+00, 0.0000e+00],\n",
              "        [2.3682e+03, 3.2924e-41, 1.3593e-43, 0.0000e+00]])"
            ]
          },
          "metadata": {},
          "execution_count": 58
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 3.0 - torch.empty_like(input_tensor) -> Returns an uninitialized tensor with the same size as input.\n",
        "input_tensor = torch.empty((3, 4), dtype=torch.int32)\n",
        "\n",
        "empty_like_tensor = torch.empty_like(input_tensor)\n",
        "empty_like_tensor"
      ],
      "metadata": {
        "id": "4fYUmLVUVKLX",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "19c19da6-9826-4174-a19d-69769d36148c"
      },
      "execution_count": 59,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[-111692672,      23490, -111764080,      23490],\n",
              "        [         1,          0, -111785920,      23490],\n",
              "        [ 561194592,      31315, -111785920,      23490]], dtype=torch.int32)"
            ]
          },
          "metadata": {},
          "execution_count": 59
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 3.1 ->"
      ],
      "metadata": {
        "id": "k46XgHQwVKN2"
      },
      "execution_count": 60,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "x = torch.rand(3, 100)\n",
        "x, x.shape, x.ndim"
      ],
      "metadata": {
        "id": "zKyqERiCVKP3",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9e814d13-adac-407f-fe18-405aeaf0b183"
      },
      "execution_count": 61,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor([[8.8044e-02, 6.3602e-02, 8.8195e-01, 8.5240e-02, 3.1369e-01, 2.6944e-01,\n",
              "          8.6670e-01, 9.5565e-01, 3.0780e-01, 7.5683e-01, 2.0725e-01, 3.4714e-01,\n",
              "          4.6998e-01, 2.0735e-01, 6.5807e-01, 9.5615e-01, 5.8262e-01, 2.5419e-01,\n",
              "          4.4357e-01, 2.9295e-01, 7.8577e-01, 3.9001e-01, 8.9745e-02, 5.3600e-01,\n",
              "          9.8041e-01, 7.5764e-01, 1.7787e-01, 5.6074e-01, 4.3668e-01, 3.8820e-01,\n",
              "          5.9794e-02, 6.8732e-01, 4.3531e-02, 8.2958e-01, 2.7647e-01, 3.3656e-01,\n",
              "          4.4210e-01, 7.0750e-01, 6.4048e-01, 8.3917e-01, 3.8662e-01, 8.6251e-01,\n",
              "          6.5511e-01, 2.9556e-02, 4.9676e-01, 6.4653e-01, 6.6580e-01, 9.8931e-01,\n",
              "          9.5600e-01, 8.7140e-01, 2.6837e-01, 5.8115e-01, 7.9386e-03, 1.0414e-02,\n",
              "          2.8151e-01, 7.5777e-01, 2.0565e-01, 7.4992e-01, 1.5739e-01, 5.8599e-01,\n",
              "          3.0448e-01, 2.8610e-02, 6.4476e-01, 5.8234e-01, 6.0530e-01, 5.8118e-01,\n",
              "          3.7200e-01, 4.7594e-01, 3.6924e-02, 1.8307e-01, 7.6388e-02, 1.4817e-02,\n",
              "          6.8327e-02, 3.3639e-01, 1.3604e-01, 3.5160e-01, 3.6241e-01, 3.4145e-01,\n",
              "          7.6128e-01, 3.6496e-01, 4.2117e-01, 7.2428e-01, 9.7091e-01, 5.0817e-01,\n",
              "          9.8342e-02, 3.9889e-03, 3.0284e-01, 1.7191e-01, 8.6808e-01, 9.2217e-01,\n",
              "          4.3204e-01, 8.7929e-01, 1.0741e-01, 1.9453e-01, 8.7131e-01, 3.2736e-01,\n",
              "          9.4169e-01, 2.6029e-01, 5.1979e-01, 1.7913e-01],\n",
              "         [8.7982e-01, 4.5239e-01, 7.4609e-01, 1.0555e-01, 1.2427e-01, 4.5575e-01,\n",
              "          6.2816e-01, 9.2941e-01, 1.5928e-01, 5.2104e-01, 9.6274e-01, 5.9238e-01,\n",
              "          3.0049e-01, 3.0081e-01, 9.9120e-01, 4.1077e-02, 3.2996e-01, 5.3268e-01,\n",
              "          8.1237e-01, 2.9429e-02, 8.0975e-01, 8.3595e-01, 1.6601e-01, 5.8686e-01,\n",
              "          2.2138e-01, 5.7765e-01, 5.7856e-01, 7.3058e-01, 5.0748e-01, 3.5905e-01,\n",
              "          2.8267e-01, 1.1306e-01, 5.8943e-01, 2.4441e-01, 4.6773e-01, 2.5008e-01,\n",
              "          6.6430e-01, 4.5091e-01, 3.7829e-02, 7.7034e-01, 5.8087e-01, 6.6679e-01,\n",
              "          4.4997e-01, 9.2593e-01, 5.9141e-01, 1.3306e-01, 7.8914e-01, 5.2573e-02,\n",
              "          3.3218e-01, 6.5694e-01, 5.8826e-01, 6.3842e-01, 8.5039e-01, 4.6713e-01,\n",
              "          7.1392e-02, 3.9527e-01, 1.8397e-01, 8.0918e-01, 5.0524e-01, 9.0653e-01,\n",
              "          2.0432e-03, 8.8168e-01, 2.5457e-01, 3.1860e-01, 7.7506e-01, 2.0099e-01,\n",
              "          4.3956e-01, 5.8909e-01, 5.5119e-01, 3.9426e-01, 4.2307e-01, 8.4826e-01,\n",
              "          5.0841e-01, 1.6752e-01, 4.3167e-02, 9.4396e-04, 2.1256e-02, 3.8843e-01,\n",
              "          9.5168e-01, 4.1062e-01, 9.3798e-02, 3.2469e-01, 6.9545e-01, 1.7310e-02,\n",
              "          9.5336e-01, 9.8152e-01, 6.4348e-01, 8.8812e-01, 4.1634e-01, 1.7331e-01,\n",
              "          4.2521e-01, 3.3069e-01, 9.9529e-01, 3.3161e-01, 8.9104e-01, 3.4993e-01,\n",
              "          6.8669e-01, 1.5315e-01, 1.1932e-01, 8.2533e-01],\n",
              "         [6.2281e-01, 2.4189e-02, 3.1144e-01, 6.9042e-01, 3.5496e-01, 9.3883e-01,\n",
              "          5.9728e-01, 5.9973e-01, 3.1156e-01, 3.9519e-01, 4.6560e-01, 5.3344e-01,\n",
              "          8.4463e-01, 8.7673e-01, 8.5662e-01, 4.7601e-01, 7.2944e-01, 7.0061e-01,\n",
              "          1.2768e-01, 7.6516e-01, 6.7741e-02, 3.5614e-01, 4.9544e-01, 6.3144e-01,\n",
              "          7.5237e-01, 2.6903e-01, 7.3540e-01, 4.4661e-01, 2.1110e-01, 1.9437e-01,\n",
              "          5.0284e-01, 3.6265e-01, 5.7763e-02, 7.1621e-01, 1.5099e-02, 2.6842e-01,\n",
              "          4.6638e-01, 5.4834e-02, 7.4399e-01, 2.1458e-01, 8.0068e-01, 1.9839e-01,\n",
              "          6.2521e-01, 6.7145e-01, 6.0903e-01, 9.4410e-01, 6.6301e-01, 1.7171e-01,\n",
              "          3.1949e-01, 3.3238e-01, 9.6590e-01, 3.6692e-01, 2.2626e-02, 7.6197e-01,\n",
              "          4.9174e-01, 2.2900e-01, 8.5005e-01, 4.8222e-01, 6.5232e-01, 9.0580e-01,\n",
              "          9.1165e-01, 7.8346e-01, 2.9015e-01, 9.8818e-01, 2.8935e-01, 8.0895e-01,\n",
              "          2.6425e-01, 4.8590e-01, 5.5888e-01, 4.6336e-01, 3.3393e-01, 3.9973e-01,\n",
              "          4.7328e-01, 7.4886e-01, 9.9701e-01, 9.1316e-01, 6.0814e-01, 5.2175e-01,\n",
              "          7.0155e-01, 6.3929e-01, 6.7687e-01, 1.0084e-01, 7.8526e-01, 7.1851e-01,\n",
              "          4.4248e-01, 2.0239e-01, 4.8738e-01, 9.6480e-01, 5.2352e-01, 3.4445e-01,\n",
              "          2.4928e-01, 9.4557e-01, 1.3238e-01, 9.1807e-01, 6.1438e-02, 1.5013e-01,\n",
              "          7.9957e-01, 5.9996e-01, 9.8701e-01, 3.9636e-01]]),\n",
              " torch.Size([3, 100]),\n",
              " 2)"
            ]
          },
          "metadata": {},
          "execution_count": 61
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x.stride()"
      ],
      "metadata": {
        "id": "9DTD4nXfVKSQ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5c17d84b-95a4-40d2-ad46-ba44b357f4f4"
      },
      "execution_count": 62,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(100, 1)"
            ]
          },
          "metadata": {},
          "execution_count": 62
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a 2D array\n",
        "x = torch.tensor(\n",
        "    [\n",
        "\n",
        "              [0, 1, 2, 3, 4,7],\n",
        "              [5, 6, 7, 8, 9,8],\n",
        "\n",
        "    ], dtype=torch.int32)\n",
        "\n",
        "x.stride(), x.ndim"
      ],
      "metadata": {
        "id": "eUBaOsg7VKUz",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "467d0793-0c88-42d8-f27c-0ec52aa01bc6"
      },
      "execution_count": 63,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "((6, 1), 2)"
            ]
          },
          "metadata": {},
          "execution_count": 63
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x[0][0].item() #x_00"
      ],
      "metadata": {
        "id": "V8xyYA6IVKW8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "93f94fbd-75f2-42cf-ae95-303f8911302c"
      },
      "execution_count": 64,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "metadata": {},
          "execution_count": 64
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#x_10\n",
        "x[1][0]"
      ],
      "metadata": {
        "id": "PvKURH9PVKZP",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d37d64a6-b878-427d-cb06-aeda9367ddc3"
      },
      "execution_count": 65,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor(5, dtype=torch.int32)"
            ]
          },
          "metadata": {},
          "execution_count": 65
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "t = torch.tensor(np.array([[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]], dtype=np.int32))\n",
        "t.stride()"
      ],
      "metadata": {
        "id": "1Th7pdYaVKbx",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0f5ca0a4-e76a-41e4-a73c-7e7d1bdb9c78"
      },
      "execution_count": 66,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(5, 1)"
            ]
          },
          "metadata": {},
          "execution_count": 66
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x = torch.arange(12).view((3,4))\n",
        "x"
      ],
      "metadata": {
        "id": "SEzggEWyVKeM",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2418e029-2397-4019-b085-7bec555b7fca"
      },
      "execution_count": 67,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[ 0,  1,  2,  3],\n",
              "        [ 4,  5,  6,  7],\n",
              "        [ 8,  9, 10, 11]])"
            ]
          },
          "metadata": {},
          "execution_count": 67
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "idx = (2, 1)\n",
        "item = x[idx].item()\n",
        "item"
      ],
      "metadata": {
        "id": "80rdMHQ5VKgw",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2233a960-a100-4a52-c266-a333a5878ccf"
      },
      "execution_count": 68,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "9"
            ]
          },
          "metadata": {},
          "execution_count": 68
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# torch.squeeze()\n",
        "x = torch.rand(1,5,3,1,2,1)\n",
        "\n",
        "print({x}, {x.ndim}, {x.shape})\n",
        "\n",
        "sq = torch.squeeze(x)\n",
        "print({sq}, {sq.ndim}, {sq.shape})"
      ],
      "metadata": {
        "id": "uDgcMimPVKjG",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0be1c07c-06c2-4065-c5e5-186b517a920c"
      },
      "execution_count": 87,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{tensor([[[[[[0.8549],\n",
            "            [0.5509]]],\n",
            "\n",
            "\n",
            "          [[[0.2868],\n",
            "            [0.2063]]],\n",
            "\n",
            "\n",
            "          [[[0.4451],\n",
            "            [0.3593]]]],\n",
            "\n",
            "\n",
            "\n",
            "         [[[[0.7204],\n",
            "            [0.0731]]],\n",
            "\n",
            "\n",
            "          [[[0.9699],\n",
            "            [0.1078]]],\n",
            "\n",
            "\n",
            "          [[[0.8829],\n",
            "            [0.4132]]]],\n",
            "\n",
            "\n",
            "\n",
            "         [[[[0.7572],\n",
            "            [0.6948]]],\n",
            "\n",
            "\n",
            "          [[[0.5209],\n",
            "            [0.5932]]],\n",
            "\n",
            "\n",
            "          [[[0.8797],\n",
            "            [0.6286]]]],\n",
            "\n",
            "\n",
            "\n",
            "         [[[[0.7653],\n",
            "            [0.1132]]],\n",
            "\n",
            "\n",
            "          [[[0.8559],\n",
            "            [0.6721]]],\n",
            "\n",
            "\n",
            "          [[[0.6267],\n",
            "            [0.5691]]]],\n",
            "\n",
            "\n",
            "\n",
            "         [[[[0.7437],\n",
            "            [0.9592]]],\n",
            "\n",
            "\n",
            "          [[[0.3887],\n",
            "            [0.2214]]],\n",
            "\n",
            "\n",
            "          [[[0.3742],\n",
            "            [0.1953]]]]]])} {6} {torch.Size([1, 5, 3, 1, 2, 1])}\n",
            "{tensor([[[0.8549, 0.5509],\n",
            "         [0.2868, 0.2063],\n",
            "         [0.4451, 0.3593]],\n",
            "\n",
            "        [[0.7204, 0.0731],\n",
            "         [0.9699, 0.1078],\n",
            "         [0.8829, 0.4132]],\n",
            "\n",
            "        [[0.7572, 0.6948],\n",
            "         [0.5209, 0.5932],\n",
            "         [0.8797, 0.6286]],\n",
            "\n",
            "        [[0.7653, 0.1132],\n",
            "         [0.8559, 0.6721],\n",
            "         [0.6267, 0.5691]],\n",
            "\n",
            "        [[0.7437, 0.9592],\n",
            "         [0.3887, 0.2214],\n",
            "         [0.3742, 0.1953]]])} {3} {torch.Size([5, 3, 2])}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# torch.unsqueeze() -> Returns a new tensor with a dimension of size one inserted at the specified position.\n",
        "us = torch.unsqueeze(sq, 2)\n",
        "print({us}, {us.shape}, {us.ndim})"
      ],
      "metadata": {
        "id": "W1cY5YjtVKl8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ddd05e70-ef28-4996-a5f3-ab26a9fcc59e"
      },
      "execution_count": 91,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{tensor([[[[0.8549, 0.5509]],\n",
            "\n",
            "         [[0.2868, 0.2063]],\n",
            "\n",
            "         [[0.4451, 0.3593]]],\n",
            "\n",
            "\n",
            "        [[[0.7204, 0.0731]],\n",
            "\n",
            "         [[0.9699, 0.1078]],\n",
            "\n",
            "         [[0.8829, 0.4132]]],\n",
            "\n",
            "\n",
            "        [[[0.7572, 0.6948]],\n",
            "\n",
            "         [[0.5209, 0.5932]],\n",
            "\n",
            "         [[0.8797, 0.6286]]],\n",
            "\n",
            "\n",
            "        [[[0.7653, 0.1132]],\n",
            "\n",
            "         [[0.8559, 0.6721]],\n",
            "\n",
            "         [[0.6267, 0.5691]]],\n",
            "\n",
            "\n",
            "        [[[0.7437, 0.9592]],\n",
            "\n",
            "         [[0.3887, 0.2214]],\n",
            "\n",
            "         [[0.3742, 0.1953]]]])} {torch.Size([5, 3, 1, 2])} {4}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Indexing, Slicing, Joining, Mutating Ops["
      ],
      "metadata": {
        "id": "rU_tqcJ6bwBV"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "BQfMwXMKo3au"
      },
      "execution_count": 69,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "vz9HZM2eW-1i"
      },
      "execution_count": 69,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# [2. Create a random tensor with shape(7,7)](https://www.learnpytorch.io/00_pytorch_fundamentals/#exercises)"
      ],
      "metadata": {
        "id": "UuZqZuSyxccH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# create random tensor\n",
        "random_tensor = torch.randn(7, 7)\n",
        "random_tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ia0ao26fxbkl",
        "outputId": "2f3aef2a-0064-429f-80f7-b8870aad157a"
      },
      "execution_count": 70,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[ 1.7960,  0.0664, -0.1379,  0.1600,  0.1694,  1.3935,  0.4854],\n",
              "        [ 1.4234,  0.4005, -0.7899,  0.1215, -0.7202, -0.0455,  1.7585],\n",
              "        [ 0.3135,  0.2611,  1.1616,  0.2869, -1.1168, -1.6596,  1.9179],\n",
              "        [-0.1791,  0.6051,  0.4286,  0.4196, -0.7494,  0.1484,  0.2248],\n",
              "        [ 0.5402, -0.5034, -0.0051, -1.3855, -0.0237, -1.5907,  0.7113],\n",
              "        [-0.2446, -0.4792, -0.0748, -1.9085, -0.2709,  1.3819, -0.1018],\n",
              "        [-1.7180,  1.0361,  0.5801, -0.6172, -0.1982,  1.2178,  0.0459]])"
            ]
          },
          "metadata": {},
          "execution_count": 70
        }
      ]
    },
    {
      "cell_type": "markdown",
      "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)](https://www.learnpytorch.io/00_pytorch_fundamentals/#exercises)"
      ],
      "metadata": {
        "id": "aTgM9yC7x4YT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "second_random_tensor = torch.randn(1, 7)\n",
        "second_random_tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "B8DdZJmux0Sd",
        "outputId": "21122cb5-d1fd-420a-ff3a-860c1c7a3e00"
      },
      "execution_count": 71,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[ 0.0472, -3.0259,  1.3833, -1.8704,  0.3775, -1.4348, -0.6533]])"
            ]
          },
          "metadata": {},
          "execution_count": 71
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# multiplication\n",
        "#mul_tensor = torch.matmul(random_tensor, second_random_tensor) # generate error because of shape issue(mat1 and mat2 shapes cannot be multiplied (7x7 and 1x7))\n",
        "#mul_tensor"
      ],
      "metadata": {
        "id": "kNSzLEPVzQfT"
      },
      "execution_count": 72,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# hence we have to transpose second_random_tensor to solve the issue\n",
        "transpose_of_second_random_tensor = second_random_tensor.T\n",
        "transpose_of_second_random_tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "E1fRUgg90Mj6",
        "outputId": "53d7cafc-260c-47c0-9825-103395dedbb9"
      },
      "execution_count": 73,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[ 0.0472],\n",
              "        [-3.0259],\n",
              "        [ 1.3833],\n",
              "        [-1.8704],\n",
              "        [ 0.3775],\n",
              "        [-1.4348],\n",
              "        [-0.6533]])"
            ]
          },
          "metadata": {},
          "execution_count": 73
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# again try to multiplication\n",
        "mul_tensor = torch.matmul(random_tensor, transpose_of_second_random_tensor)\n",
        "mul_tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XUbjwCeZ0qRZ",
        "outputId": "75314547-7b16-455b-8322-888ee8d8302d"
      },
      "execution_count": 74,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[-2.8585],\n",
              "        [-3.8199],\n",
              "        [ 1.0017],\n",
              "        [-2.6741],\n",
              "        [ 5.9419],\n",
              "        [ 2.8861],\n",
              "        [-3.1114]])"
            ]
          },
          "metadata": {},
          "execution_count": 74
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#[4. Set the random seed to 0 and do exercises 2 & 3 over again.](https://www.learnpytorch.io/00_pytorch_fundamentals/#exercises)"
      ],
      "metadata": {
        "id": "c1aK9mVQ2DKp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# set the manual seed\n",
        "torch.manual_seed(0)\n",
        "\n",
        "# create two random tensor\n",
        "X = torch.rand(size=(7, 7))\n",
        "Y = torch.rand(size=(1, 7))\n",
        "\n",
        "# Matrix multiply tensors\n",
        "Z = torch.matmul(X, Y.T)\n",
        "Z, Z.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5r6iTgZA2ETK",
        "outputId": "13ad2051-c7dc-4ab2-bcea-269d79456642"
      },
      "execution_count": 75,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor([[1.8542],\n",
              "         [1.9611],\n",
              "         [2.2884],\n",
              "         [3.0481],\n",
              "         [1.7067],\n",
              "         [2.5290],\n",
              "         [1.7989]]),\n",
              " torch.Size([7, 1]))"
            ]
          },
          "metadata": {},
          "execution_count": 75
        }
      ]
    },
    {
      "cell_type": "markdown",
      "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). If there is, set the GPU random seed to `1234`.](https://www.learnpytorch.io/00_pytorch_fundamentals/#exercises)"
      ],
      "metadata": {
        "id": "yZszLzMF3d6d"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# set the random seed on the GPU\n",
        "torch.cuda.manual_seed(1234)"
      ],
      "metadata": {
        "id": "w6kxLF3P06Iy"
      },
      "execution_count": 76,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# [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).](https://www.learnpytorch.io/00_pytorch_fundamentals/#exercises)"
      ],
      "metadata": {
        "id": "qAJZ9DO45Qks"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# set random seed\n",
        "torch.manual_seed(1234)\n",
        "\n",
        "# check for access to GPU\n",
        "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
        "print(device)\n",
        "\n",
        "# create two random tensors on GPU\n",
        "tensor1 = torch.rand(2, 3).to(device)\n",
        "print(tensor1)\n",
        "tensor2 = torch.rand(2, 3).to(device)\n",
        "print(tensor2)\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gIR8lWS62F4o",
        "outputId": "85c84dca-ddbe-436e-debd-99b24a579e15"
      },
      "execution_count": 77,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "cpu\n",
            "tensor([[0.0290, 0.4019, 0.2598],\n",
            "        [0.3666, 0.0583, 0.7006]])\n",
            "tensor([[0.0518, 0.4681, 0.6738],\n",
            "        [0.3315, 0.7837, 0.5631]])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# [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).](https://www.learnpytorch.io/00_pytorch_fundamentals/#exercises)"
      ],
      "metadata": {
        "id": "W34aJrhJ62Qk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# transpose of second tensor(tensor2)\n",
        "transpose_of_tensor2 = tensor2.T\n",
        "print(transpose_of_tensor2.shape)\n",
        "\n",
        "# multiplication\n",
        "mul_tensor1_tensor2 = torch.matmul(tensor1, transpose_of_tensor2)\n",
        "mul_tensor1_tensor2, mul_tensor1_tensor2.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YbWr4Yfs2F2Y",
        "outputId": "12cd53b9-6642-4aee-b1b0-61e661ba7762"
      },
      "execution_count": 78,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([3, 2])\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor([[0.3647, 0.4709],\n",
              "         [0.5184, 0.5617]]),\n",
              " torch.Size([2, 2]))"
            ]
          },
          "metadata": {},
          "execution_count": 78
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# [8. Find the maximum and minimum values of the output of exercise no. 7](https://www.learnpytorch.io/00_pytorch_fundamentals/#exercises)"
      ],
      "metadata": {
        "id": "p4NETdHZ8tcu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# maximum\n",
        "max_of_mul_tensor1_tensor2 = torch.max(mul_tensor1_tensor2)\n",
        "print(max_of_mul_tensor1_tensor2)\n",
        "\n",
        "# minimum\n",
        "min_of_mul_tensor1_tensor2 = torch.min(mul_tensor1_tensor2)\n",
        "print(min_of_mul_tensor1_tensor2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7qReCG_E2Fz1",
        "outputId": "2386e34e-f4f9-4a8a-b9bb-e969d1e03b41"
      },
      "execution_count": 79,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor(0.5617)\n",
            "tensor(0.3647)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# [9. Find the maximum and minimum index values of the output of exercise no. 7.](https://www.learnpytorch.io/00_pytorch_fundamentals/#exercises)"
      ],
      "metadata": {
        "id": "kYJwqQ9K9uZI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#\n",
        "arg_max = torch.argmax(mul_tensor1_tensor2)\n",
        "\n",
        "arg_min = torch.argmin(mul_tensor1_tensor2)\n",
        "\n",
        "arg_max, arg_min"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xQt8mgpp2FxR",
        "outputId": "a68d29f2-8a6b-436b-9cf3-c1f6b67231e7"
      },
      "execution_count": 80,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor(3), tensor(0))"
            ]
          },
          "metadata": {},
          "execution_count": 80
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "torch.manual_seed(1111)\n",
        "t = torch.rand(5,10,10)\n",
        "print(t)\n",
        "print(t.ndim)\n",
        "\n",
        "print(torch.max(t))\n",
        "print(torch.min(t))\n",
        "\n",
        "print(torch.argmax(t))\n",
        "print(torch.argmin(t))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Oxl8L6kNRJq3",
        "outputId": "add36344-cf29-422e-fbc7-583753ce0a28"
      },
      "execution_count": 81,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([[[0.4606, 0.0850, 0.8009, 0.3972, 0.9548, 0.5982, 0.4821, 0.9446,\n",
            "          0.5145, 0.8125],\n",
            "         [0.3122, 0.9756, 0.8747, 0.7186, 0.3945, 0.4090, 0.8398, 0.7494,\n",
            "          0.8129, 0.3084],\n",
            "         [0.3856, 0.0044, 0.3022, 0.1679, 0.3270, 0.7481, 0.7058, 0.7362,\n",
            "          0.4007, 0.3604],\n",
            "         [0.3799, 0.2386, 0.2630, 0.6923, 0.6288, 0.2374, 0.7273, 0.2219,\n",
            "          0.0023, 0.0519],\n",
            "         [0.6212, 0.0702, 0.1679, 0.7474, 0.3838, 0.8765, 0.0847, 0.0438,\n",
            "          0.0240, 0.8543],\n",
            "         [0.9728, 0.9800, 0.8626, 0.3807, 0.2407, 0.1545, 0.1941, 0.2021,\n",
            "          0.1576, 0.2454],\n",
            "         [0.6102, 0.9753, 0.2276, 0.8281, 0.0622, 0.8240, 0.7640, 0.5675,\n",
            "          0.3867, 0.2336],\n",
            "         [0.0367, 0.9595, 0.7285, 0.1776, 0.7983, 0.0488, 0.4074, 0.6836,\n",
            "          0.7789, 0.5250],\n",
            "         [0.3852, 0.5046, 0.3091, 0.3106, 0.4996, 0.0484, 0.8811, 0.7156,\n",
            "          0.5041, 0.5557],\n",
            "         [0.2471, 0.7452, 0.6895, 0.1305, 0.5353, 0.9120, 0.3374, 0.9799,\n",
            "          0.1652, 0.2319]],\n",
            "\n",
            "        [[0.3430, 0.4789, 0.7967, 0.3651, 0.5562, 0.6197, 0.9343, 0.8954,\n",
            "          0.6516, 0.0248],\n",
            "         [0.8594, 0.9171, 0.5977, 0.6173, 0.5328, 0.0891, 0.3438, 0.5938,\n",
            "          0.3024, 0.5325],\n",
            "         [0.6995, 0.8409, 0.4631, 0.5659, 0.7866, 0.2150, 0.8105, 0.6985,\n",
            "          0.7523, 0.1988],\n",
            "         [0.7240, 0.7413, 0.7827, 0.8698, 0.9913, 0.1017, 0.7286, 0.6081,\n",
            "          0.8445, 0.5618],\n",
            "         [0.8996, 0.4108, 0.7312, 0.2695, 0.6945, 0.8618, 0.4468, 0.1239,\n",
            "          0.7805, 0.5653],\n",
            "         [0.9625, 0.2153, 0.5057, 0.5783, 0.6242, 0.9585, 0.1398, 0.7538,\n",
            "          0.3269, 0.1786],\n",
            "         [0.7421, 0.7278, 0.4301, 0.2060, 0.8391, 0.6356, 0.6218, 0.3952,\n",
            "          0.1875, 0.5326],\n",
            "         [0.6768, 0.0813, 0.3312, 0.4790, 0.8915, 0.8821, 0.9529, 0.3860,\n",
            "          0.7178, 0.0947],\n",
            "         [0.8657, 0.8961, 0.2120, 0.0235, 0.4267, 0.7658, 0.3638, 0.2637,\n",
            "          0.9218, 0.7619],\n",
            "         [0.3013, 0.9704, 0.6831, 0.3815, 0.8286, 0.8374, 0.3571, 0.8206,\n",
            "          0.1943, 0.7410]],\n",
            "\n",
            "        [[0.8895, 0.5749, 0.7386, 0.6324, 0.1932, 0.9204, 0.9787, 0.3014,\n",
            "          0.9717, 0.0281],\n",
            "         [0.3258, 0.0031, 0.9513, 0.2358, 0.4632, 0.1277, 0.7981, 0.9733,\n",
            "          0.1135, 0.7250],\n",
            "         [0.5296, 0.6038, 0.7169, 0.6222, 0.0606, 0.3816, 0.7513, 0.7344,\n",
            "          0.0964, 0.1684],\n",
            "         [0.7726, 0.3487, 0.7458, 0.1656, 0.3075, 0.5526, 0.3061, 0.3786,\n",
            "          0.6766, 0.2430],\n",
            "         [0.2070, 0.8843, 0.8278, 0.0689, 0.5814, 0.6592, 0.2375, 0.3984,\n",
            "          0.6395, 0.1439],\n",
            "         [0.7824, 0.4705, 0.7971, 0.9338, 0.0399, 0.9106, 0.5104, 0.4350,\n",
            "          0.1388, 0.9525],\n",
            "         [0.5846, 0.3584, 0.2338, 0.0653, 0.0362, 0.1145, 0.2773, 0.7448,\n",
            "          0.8903, 0.4029],\n",
            "         [0.1679, 0.3886, 0.3402, 0.8869, 0.2515, 0.0620, 0.2303, 0.7046,\n",
            "          0.8595, 0.9012],\n",
            "         [0.7463, 0.9751, 0.7842, 0.4734, 0.3573, 0.2163, 0.7803, 0.9146,\n",
            "          0.9053, 0.9172],\n",
            "         [0.3270, 0.1731, 0.9371, 0.8194, 0.5480, 0.3174, 0.8064, 0.6399,\n",
            "          0.6835, 0.3866]],\n",
            "\n",
            "        [[0.1764, 0.2793, 0.9304, 0.6035, 0.1218, 0.1012, 0.0165, 0.7754,\n",
            "          0.2482, 0.1536],\n",
            "         [0.0774, 0.9819, 0.1227, 0.3622, 0.6419, 0.7015, 0.0483, 0.5892,\n",
            "          0.3332, 0.4559],\n",
            "         [0.5696, 0.0974, 0.8295, 0.8213, 0.5352, 0.1177, 0.0798, 0.1535,\n",
            "          0.8742, 0.5619],\n",
            "         [0.9416, 0.5733, 0.7656, 0.3996, 0.0373, 0.1346, 0.7744, 0.6180,\n",
            "          0.8342, 0.5494],\n",
            "         [0.5785, 0.1830, 0.8855, 0.2655, 0.8898, 0.2820, 0.0369, 0.5495,\n",
            "          0.3923, 0.9117],\n",
            "         [0.6401, 0.5776, 0.6887, 0.6903, 0.2030, 0.7250, 0.2557, 0.3905,\n",
            "          0.6957, 0.8386],\n",
            "         [0.7324, 0.3447, 0.3251, 0.8489, 0.5552, 0.5841, 0.2593, 0.4567,\n",
            "          0.8850, 0.6504],\n",
            "         [0.4739, 0.5856, 0.8177, 0.0070, 0.2072, 0.2307, 0.2875, 0.4782,\n",
            "          0.5748, 0.5157],\n",
            "         [0.2430, 0.2978, 0.7741, 0.1170, 0.3207, 0.6645, 0.5343, 0.2471,\n",
            "          0.7725, 0.4524],\n",
            "         [0.8791, 0.5534, 0.2892, 0.7214, 0.4055, 0.5729, 0.6308, 0.0688,\n",
            "          0.4447, 0.8304]],\n",
            "\n",
            "        [[0.5275, 0.0482, 0.8196, 0.7425, 0.6874, 0.4898, 0.6340, 0.3195,\n",
            "          0.7538, 0.0010],\n",
            "         [0.5194, 0.9214, 0.4857, 0.3742, 0.4509, 0.0225, 0.9552, 0.3738,\n",
            "          0.4213, 0.2021],\n",
            "         [0.9395, 0.7855, 0.3824, 0.1071, 0.7541, 0.2409, 0.4952, 0.6622,\n",
            "          0.1877, 0.3832],\n",
            "         [0.0369, 0.3435, 0.0149, 0.7391, 0.7898, 0.2621, 0.1012, 0.8083,\n",
            "          0.6699, 0.4176],\n",
            "         [0.3133, 0.5289, 0.7320, 0.7279, 0.3805, 0.8834, 0.7000, 0.3628,\n",
            "          0.2180, 0.0200],\n",
            "         [0.7655, 0.8829, 0.5198, 0.8429, 0.1416, 0.5478, 0.3975, 0.5480,\n",
            "          0.3829, 0.8126],\n",
            "         [0.6558, 0.2564, 0.0764, 0.1114, 0.1861, 0.0411, 0.4386, 0.3309,\n",
            "          0.5282, 0.2449],\n",
            "         [0.2558, 0.4719, 0.8867, 0.5216, 0.4270, 0.9439, 0.1578, 0.2906,\n",
            "          0.1958, 0.3326],\n",
            "         [0.6335, 0.8115, 0.4831, 0.6739, 0.2806, 0.2548, 0.2780, 0.1759,\n",
            "          0.9697, 0.8716],\n",
            "         [0.0525, 0.8729, 0.2233, 0.2676, 0.1704, 0.1509, 0.0065, 0.2224,\n",
            "          0.6362, 0.6009]]])\n",
            "3\n",
            "tensor(0.9913)\n",
            "tensor(0.0010)\n",
            "tensor(134)\n",
            "tensor(409)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "rZ2yamRjRKV0"
      },
      "execution_count": 81,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "mul_tensor1_tensor2"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xLiGzWrh2FsK",
        "outputId": "02097633-c88d-4697-8eb9-a00e35dc498a"
      },
      "execution_count": 82,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[0.3647, 0.4709],\n",
              "        [0.5184, 0.5617]])"
            ]
          },
          "metadata": {},
          "execution_count": 82
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# [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.](https://www.learnpytorch.io/00_pytorch_fundamentals/#exercises)"
      ],
      "metadata": {
        "id": "9q3CxvSJNSdM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# create random tensor\n",
        "torch.manual_seed(7)\n",
        "r_tensor = torch.rand(1, 1, 1, 10)\n",
        "print(r_tensor)\n",
        "print(r_tensor.shape)\n",
        "\n",
        "# remove the single dimensions\n",
        "new_tensor = torch.squeeze(r_tensor)\n",
        "print(new_tensor)\n",
        "print(new_tensor.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-fIVaYiq2FjS",
        "outputId": "cbf9cbd7-13db-475c-89e8-86bd60b89172"
      },
      "execution_count": 83,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([[[[0.5349, 0.1988, 0.6592, 0.6569, 0.2328, 0.4251, 0.2071, 0.6297,\n",
            "           0.3653, 0.8513]]]])\n",
            "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])\n",
            "torch.Size([10])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "Uq4oL-mO2FYZ"
      },
      "execution_count": 83,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "cxXJVnIm2FK0"
      },
      "execution_count": 83,
      "outputs": []
    }
  ]
}