assignment_1 - torch_tensor_operations.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/abhx7/Deep-Learning-with-PyTorch---GANS/blob/main/01_tensor_operations.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PmFZwtjQroPa"
      },
      "source": [
        "# Introduction to PyTorch Tensors\n",
        "\n",
        "A tensor is a number, vector, matrix or any n-dimensional array. Fundamentally, PyTorch is a library for processing tensors. We will be looking into the workings of some functions of this library through examples.\n",
        "\n",
        "- linspace\n",
        "- split\n",
        "- cat\n",
        "- trig functions\n",
        "- randint\n",
        "\n",
        "Before we begin, let's install and import PyTorch"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ze8N4OuBroPu"
      },
      "source": [
        "## Lesson 1 Summary\n",
        "\n",
        "* In the first lesson, we leart how to work with tensors and generating its gradient as it would be useful for linear regression.\n",
        "* We also discussed its interoperability with numpy and why pytorch is needed inspite of numpy covering most of its abilities.\n",
        "* Next, we learnt to [train a model using linear regression through gradient descent](https://jovian.ai/aakashns/02-linear-regression). We did this first manually and then through pytorch inbuilts\n",
        "* Finally we were introduced a bit to the [concept of machine learning in contrast to classical programming as well as linear regression being the most simple neural network](https://jovian.ai/aakashns/machine-learning-intro)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "h-ZDTrUVroPb"
      },
      "outputs": [],
      "source": [
        "# Uncomment and run the appropriate command for your operating system, if required\n",
        "\n",
        "# Linux / Binder\n",
        "# !pip install numpy torch==1.7.0+cpu torchvision==0.8.1+cpu torchaudio==0.7.0 -f https://download.pytorch.org/whl/torch_stable.html\n",
        "\n",
        "# Windows\n",
        "# !pip install numpy torch==1.7.0+cpu torchvision==0.8.1+cpu torchaudio==0.7.0 -f https://download.pytorch.org/whl/torch_stable.html\n",
        "\n",
        "# MacOS\n",
        "# !pip install numpy torch torchvision torchaudio"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "X6LF8decroPd"
      },
      "outputs": [],
      "source": [
        "# Import torch and other required modules\n",
        "import torch"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x8Eeuo9NroPd"
      },
      "source": [
        "## Function 1 - torch.linspace(a,b,n)\n",
        "\n",
        "Creates a one dimensional tensor with n elements equally spaced from a to b, including the both ends."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bM1IOAIAroPe",
        "outputId": "f23fdaf0-4a3a-40e0-e456-39c017f6574e"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([ 0.0000,  0.1000,  0.2000,  0.3000,  0.4000,  0.5000,  0.6000,  0.7000,\n",
              "         0.8000,  0.9000,  1.0000,  1.1000,  1.2000,  1.3000,  1.4000,  1.5000,\n",
              "         1.6000,  1.7000,  1.8000,  1.9000,  2.0000,  2.1000,  2.2000,  2.3000,\n",
              "         2.4000,  2.5000,  2.6000,  2.7000,  2.8000,  2.9000,  3.0000,  3.1000,\n",
              "         3.2000,  3.3000,  3.4000,  3.5000,  3.6000,  3.7000,  3.8000,  3.9000,\n",
              "         4.0000,  4.1000,  4.2000,  4.3000,  4.4000,  4.5000,  4.6000,  4.7000,\n",
              "         4.8000,  4.9000,  5.0000,  5.1000,  5.2000,  5.3000,  5.4000,  5.5000,\n",
              "         5.6000,  5.7000,  5.8000,  5.9000,  6.0000,  6.1000,  6.2000,  6.3000,\n",
              "         6.4000,  6.5000,  6.6000,  6.7000,  6.8000,  6.9000,  7.0000,  7.1000,\n",
              "         7.2000,  7.3000,  7.4000,  7.5000,  7.6000,  7.7000,  7.8000,  7.9000,\n",
              "         8.0000,  8.1000,  8.2000,  8.3000,  8.4000,  8.5000,  8.6000,  8.7000,\n",
              "         8.8000,  8.9000,  9.0000,  9.1000,  9.2000,  9.3000,  9.4000,  9.5000,\n",
              "         9.6000,  9.7000,  9.8000,  9.9000, 10.0000])"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ],
      "source": [
        "# Example 1 - working\n",
        "t1a=torch.linspace (0,10,101);\n",
        "t1a"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lVRueeEsroPf"
      },
      "source": [
        "\n",
        "Creates a one dimensional tensor with 101 elements equally spaced from 0 to 10, including the both ends."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vAXBE3CYroPg",
        "outputId": "26e145de-3d13-40da-f081-fd507ae6b847"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([ 5,  4,  3,  2,  1,  0, -1, -2, -3, -4, -5], dtype=torch.int8)"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ],
      "source": [
        "# Example 2 - working\n",
        "t1b=torch.linspace (5,-5,11,dtype=torch.int8);\n",
        "t1b"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QFDPI58MroPg"
      },
      "source": [
        "Creates a one dimensional tensor with 11 integer elements equally spaced from -5 to 5, including the both ends."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 193
        },
        "id": "xaFQg8mwroPh",
        "outputId": "922a9283-91c7-4c3b-9292-0964c7a3af4e"
      },
      "outputs": [
        {
          "output_type": "error",
          "ename": "RuntimeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-7-70e10f5c322d>\u001b[0m in \u001b[0;36m<cell line: 2>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# Example 3 - breaking (to illustrate when it breaks)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlinspace\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mRuntimeError\u001b[0m: number of steps must be non-negative"
          ]
        }
      ],
      "source": [
        "# Example 3 - breaking (to illustrate when it breaks)\n",
        "torch.linspace(5,0,-3)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lXu1pXgRroPh"
      },
      "source": [
        "The number of elements need to be created must be a whole number for the tensor to be created.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AZO7GR_JroPh"
      },
      "source": [
        "Points to Note:\n",
        "*   If a is greater than b, a descending order tensor is created.\n",
        "*   We can also mention the data type of the tensor in the decleration."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q5XoWK-MroPh"
      },
      "source": [
        "Let's save our work using Jovian before continuing."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1SRpYwwfroPh",
        "outputId": "d2da4cdf-03de-4930-f8cf-3fa499d36fe2"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[?25l     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/68.6 kB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K     \u001b[91m━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[91m╸\u001b[0m\u001b[90m━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m41.0/68.6 kB\u001b[0m \u001b[31m937.1 kB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\r\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m68.6/68.6 kB\u001b[0m \u001b[31m1.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25h  Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Building wheel for uuid (setup.py) ... \u001b[?25l\u001b[?25hdone\n"
          ]
        }
      ],
      "source": [
        "!pip install jovian --upgrade --quiet"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "oamoAmYdroPi"
      },
      "outputs": [],
      "source": [
        "import jovian"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SmHMGf2KroPi",
        "outputId": "40db73a4-b8ca-4dab-f73d-2816ade3dedc"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[jovian] Detected Colab notebook...\u001b[0m\n",
            "[jovian] jovian.commit() is no longer required on Google Colab. If you ran this notebook from Jovian, \n",
            "then just save this file in Colab using Ctrl+S/Cmd+S and it will be updated on Jovian. \n",
            "Also, you can also delete this cell, it's no longer necessary.\u001b[0m\n"
          ]
        }
      ],
      "source": [
        "jovian.commit(project='01-tensor-operations-abhi')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KAWOFZrYroPi"
      },
      "source": [
        "## Function 2 - torch.cat(t1,t2)\n",
        "\n",
        "Combining the elements of 2 tensors of same shape to create one tensor"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "O5q5cwCWroPi"
      },
      "outputs": [],
      "source": [
        "# Example 1 - working\n",
        "t1=torch.tensor([[1,2],[2,3]]);\n",
        "t2=torch.tensor([[1,4],[4,1]]);\n",
        "t3=torch.cat((t1,t2));\n",
        "t3"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k3WZEM2FroPi"
      },
      "source": [
        "Combines the elements of 2 two dimensional tensors one after the other as that is the default operation."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "jfJ9jn3BroPi"
      },
      "outputs": [],
      "source": [
        "# Example 2 - working\n",
        "t1=torch.tensor([[[1,1],[1,1]],[[2,2],[2,2]]]);\n",
        "t2=torch.tensor([[[1,1],[1,1]],[[4,4],[4,4]]]);\n",
        "t3=torch.cat((t1,t2),2);"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oXlQelykroPi"
      },
      "source": [
        "Combines the row elements of 2 three dimensional tensors as it is given to add along 1st dimension."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Y36tlpeBroPj"
      },
      "outputs": [],
      "source": [
        "# Example 3 - breaking (to illustrate when it breaks)\n",
        "t1=torch.tensor([[1,2],[2,3]]);\n",
        "t2=torch.tensor([[1,4],[4,1]]);\n",
        "t3=torch.cat((t1,t2),2);\n",
        "t3"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_0NkMp14roPj"
      },
      "source": [
        "Concatenation is not possible in higher dimension than the input tensor dimesnions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CL8AWNT_roPj"
      },
      "source": [
        "Points to Note:\n",
        "\n",
        "*   torch.cat() can be seen as an inverse operation for torch.split()\n",
        "*   Non-empty tensors provided must have the same shape, except in the cat dimension (not necessary in cat dimension).\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "0NUY997-roPj"
      },
      "outputs": [],
      "source": [
        "jovian.commit(project='01-tensor-operations-abhi')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HD2EUP8NroPj"
      },
      "source": [
        "## Function 3 - torch.randint(low,high,n)\n",
        "\n",
        "Generates a tensor filled with 'n' random integers generated uniformly between low (inclusive) and high (exclusive)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "-bJ0MTk1roPj"
      },
      "outputs": [],
      "source": [
        "# Example 1 - working\n",
        "torch.randint(0,10,(10,))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "t4M6LIjJroPj"
      },
      "source": [
        "Creates a 1D tensor of 10 elements from any integer from 0 to 9."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "QRpROUa5roPk"
      },
      "outputs": [],
      "source": [
        "# Example 2 - working\n",
        "torch.randint(-5,5,(2,2,2))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c3OrYA1jroPk"
      },
      "source": [
        "Creates a 3D tensor of shape [2,2,2] with elements from any integer from -5 to 5."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 193
        },
        "id": "Y0gZqSYIroPk",
        "outputId": "5c5f4d45-d22e-4e30-d8be-cc86b241266c"
      },
      "outputs": [
        {
          "output_type": "error",
          "ename": "RuntimeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-11-5e74bb03ebe2>\u001b[0m in \u001b[0;36m<cell line: 2>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# Example 3 - breaking (to illustrate when it breaks)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrandint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mRuntimeError\u001b[0m: Trying to create tensor with negative dimension -1: [2, 2, -1]"
          ]
        }
      ],
      "source": [
        "# Example 3 - breaking (to illustrate when it breaks)\n",
        "torch.randint(3,(2,2,-1))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qs5PTUPxroPk"
      },
      "source": [
        "The size of each dimension of tensor created must be a non negative integer."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3dNwHRnKroPk"
      },
      "source": [
        "Points to Note:\n",
        "\n",
        "*   0 is the default low value.\n",
        "*   generator (torch.Generator, optional) – a pseudorandom number generator for sampling\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "YR6_AgHfroPk"
      },
      "outputs": [],
      "source": [
        "jovian.commit(project='01-tensor-operations-abhi')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CFcVUwi-roPl"
      },
      "source": [
        "## Function 4 - torch.cos()/torch.sin()/torch.log()//\n",
        "\n",
        "Returns a new tensor with the cosine/sin/whatever trignomteric operation output of the elements of input"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1vzi1bFZroPl",
        "outputId": "b2270559-b1a1-4b50-ba75-a6be2a4ef780"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[0.0000, 0.4969],\n",
              "        [1.0000, 1.0000]])"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ],
      "source": [
        "# Example 1 - working\n",
        "t1=torch.tensor([[0,0.52],[1.57,1.57]])\n",
        "torch.sin(t1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "B1e0gtyUroPl"
      },
      "source": [
        "returns a tensor with the sin of all elements of original tensor."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "msyOHUAkroPl",
        "outputId": "73999eea-2b75-41ab-d8be-66a0ee20e340"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[   -inf, -0.6539],\n",
              "        [ 0.4511,  0.4511]])"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ],
      "source": [
        "# Example 2 - working\n",
        "t1=torch.tensor([[0,0.52],[1.57,1.57]])\n",
        "torch.log(t1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mDJfSq6IroPm"
      },
      "source": [
        "returns a tensor with the log of all elements of original tensor."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "p0Cyh_ThroPr",
        "outputId": "726a8519-f90c-4525-c085-8d99671cd8d3"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[ 0.0000,  1.5708],\n",
              "        [-1.5708,     nan]])"
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ],
      "source": [
        "# Example 3 - breaking (to illustrate when it breaks)\n",
        "t1=torch.tensor([[0,1],[-1,3]])\n",
        "torch.asin(t1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rD01N1DFroPr"
      },
      "source": [
        "couldnt find a case where it breaks!!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Yx4sC-q-roPs"
      },
      "source": [
        "Points to Note:\n",
        "- the function is applied uniformly to all the elements of the tensor, regardless of the fact if the input falls in the domain of the mathematical function and one should be careful as it does not show that as an error"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qXm7IV6OroPs",
        "outputId": "96da771f-5137-4626-c09c-984aa6d7da4b"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[jovian] Detected Colab notebook...\u001b[0m\n",
            "[jovian] jovian.commit() is no longer required on Google Colab. If you ran this notebook from Jovian, \n",
            "then just save this file in Colab using Ctrl+S/Cmd+S and it will be updated on Jovian. \n",
            "Also, you can also delete this cell, it's no longer necessary.\u001b[0m\n"
          ]
        }
      ],
      "source": [
        "jovian.commit(project='01-tensor-operations-abhi')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_7zIlRXkroPs"
      },
      "source": [
        "## Function 5 - torch.normal()\n",
        "\n",
        "Generates a tensor of random numbers drawn from separate normal distributions whose mean and standard deviation are given."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "s3maUC1KroPt",
        "outputId": "358ef738-2361-4699-b9c4-9d5833190ba6"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([ 0.8870, -1.2236,  0.4472,  0.5753,  0.6565])"
            ]
          },
          "metadata": {},
          "execution_count": 26
        }
      ],
      "source": [
        "# Example 1 - working\n",
        "torch.normal(mean=0,std=1,size=(5,))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DOK4-tiSroPt"
      },
      "source": [
        "Returns a tensor of random numbers drawn from a single normal distributions whose mean is 0 and standard deviation is 1."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "LH-p9n3uroPt"
      },
      "outputs": [],
      "source": [
        "# Example 2 - working\n",
        "torch.normal(mean=torch.arange(1., 11.), std=torch.arange(1, 0, -0.1))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "duuD1Ds7roPt"
      },
      "source": [
        "Returns a tensor of random numbers drawn from seperate normal distributions whose mean and standard deviation are given."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "l1xXJojgroPt",
        "outputId": "728035cd-723b-436f-f568-a90b88f0f8e9"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[-3.0261, -1.2554,  0.4488,  2.8021],\n",
              "        [-2.0462,  0.5893,  0.1505,  1.4204]])"
            ]
          },
          "metadata": {},
          "execution_count": 30
        }
      ],
      "source": [
        "# Example 3 - breaking (to illustrate when it breaks)\n",
        "torch.normal(mean=-1, std=2.4,size=(2,4))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r6TdzTqTroPt"
      },
      "source": [
        "couldn't find any!!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "B2sEHoearoPu"
      },
      "source": [
        "Points to Note:\n",
        "- The mean is a tensor with the mean of each output element’s normal distribution\n",
        "- The std is a tensor with the standard deviation of each output element’s normal distribution\n",
        "- The shapes of mean and std don’t need to match, but the total number of elements in each tensor need to be the same."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FlJ1-jhproPu",
        "outputId": "70fe15c7-d173-413c-ee2c-98c0711b57e1"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[jovian] Detected Colab notebook...\u001b[0m\n",
            "[jovian] jovian.commit() is no longer required on Google Colab. If you ran this notebook from Jovian, \n",
            "then just save this file in Colab using Ctrl+S/Cmd+S and it will be updated on Jovian. \n",
            "Also, you can also delete this cell, it's no longer necessary.\u001b[0m\n"
          ]
        }
      ],
      "source": [
        "jovian.commit(project='01-tensor-operations-abhi')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Jn0ugOlQroPu"
      },
      "source": [
        "## Reference Links\n",
        "Links to my references and other interesting articles about tensors\n",
        "* Official documentation for tensor operations: https://pytorch.org/docs/stable/torch.html\n",
        "* ..."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HTY-E5whroPu",
        "outputId": "9a1a722f-1554-4752-bd3b-6a3610abab44"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[jovian] Detected Colab notebook...\u001b[0m\n",
            "[jovian] jovian.commit() is no longer required on Google Colab. If you ran this notebook from Jovian, \n",
            "then just save this file in Colab using Ctrl+S/Cmd+S and it will be updated on Jovian. \n",
            "Also, you can also delete this cell, it's no longer necessary.\u001b[0m\n"
          ]
        }
      ],
      "source": [
        "jovian.commit(project='01-tensor-operations-abhi')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "89X9oe5yroPu"
      },
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.8.5"
    },
    "colab": {
      "provenance": [],
      "include_colab_link": true
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}