Chapter-wise code/Code - PyTorch/1. Intro to PyTorch/01. Deep_Learning_with_PyTorch_A_60_Minute_Blitz_.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "01.Deep Learning with PyTorch: A 60 Minute Blitz .ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyNWvt2sEqXxM8zYb2uUd17J",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/purvasingh96/pytorch-examples/blob/master/Basics/01.%20Deep_Learning_with_PyTorch_A_60_Minute_Blitz_.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "u8-Y1QpZCJYi",
        "colab_type": "text"
      },
      "source": [
        "# What is PyTorch?\n",
        "A scientific computing package that is -\n",
        "* A replacement for NumPy to use the power of GPUs\n",
        "* A deep learning research platform that provides maximum flexibility and speed\n",
        "# Getting Started \n",
        "### Tensors\n",
        "\n",
        "* Empty tensor gets initialized with random values allocated at run time."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dtFBKwxtCjaj",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from __future__ import print_function\n",
        "import torch "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bHd2vgJMCpmy",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 459
        },
        "outputId": "8b814007-266e-496e-9f19-7a63e786e53c"
      },
      "source": [
        "empty_tensor = torch.empty(5, 3)\n",
        "zero_tensor = torch.zeros(5, 3, dtype=torch.long)\n",
        "direct_tensor = torch.tensor([5, 5, 6, 8])\n",
        "one_tensor = zero_tensor.new_ones(5, 3, dtype=torch.double)\n",
        "\n",
        "print('Empty Tensor : \\n', empty_tensor)\n",
        "print('\\n')\n",
        "print('Zero Tensor : \\n', zero_tensor)\n",
        "print('\\n')\n",
        "print('Direct Tensor : \\n', direct_tensor)\n",
        "print('\\n')\n",
        "print('Ones Tensor : \\n', one_tensor)"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Empty Tensor : \n",
            " tensor([[5.7450e-36, 0.0000e+00, 4.4842e-44],\n",
            "        [0.0000e+00,        nan, 1.6255e-43],\n",
            "        [2.6194e+20, 1.6427e-07, 1.6595e-07],\n",
            "        [2.1781e-04, 4.1723e-08, 6.7130e-07],\n",
            "        [3.3090e+21, 3.4003e-06, 0.0000e+00]])\n",
            "\n",
            "\n",
            "Zero Tensor : \n",
            " tensor([[0, 0, 0],\n",
            "        [0, 0, 0],\n",
            "        [0, 0, 0],\n",
            "        [0, 0, 0],\n",
            "        [0, 0, 0]])\n",
            "\n",
            "\n",
            "Direct Tensor : \n",
            " tensor([5, 5, 6, 8])\n",
            "\n",
            "\n",
            "Ones Tensor : \n",
            " tensor([[1., 1., 1.],\n",
            "        [1., 1., 1.],\n",
            "        [1., 1., 1.],\n",
            "        [1., 1., 1.],\n",
            "        [1., 1., 1.]], dtype=torch.float64)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JQChR3cSCx5B",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 170
        },
        "outputId": "123c57e9-9804-4922-d536-b956b4f8ac16"
      },
      "source": [
        "old_tensor = one_tensor\n",
        "new_tensor = torch.rand_like(old_tensor, dtype=torch.float)\n",
        "\n",
        "print('Size of new tensor : ', new_tensor.size())\n",
        "print('\\n')\n",
        "print('Old tensor with overridden dType and same size as old_tensor : \\n',new_tensor)"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Size of new tensor :  torch.Size([5, 3])\n",
            "\n",
            "\n",
            "Old tensor with overridden dType and same size as old_tensor : \n",
            " tensor([[0.5932, 0.1361, 0.9276],\n",
            "        [0.4668, 0.4190, 0.5359],\n",
            "        [0.6300, 0.0740, 0.5790],\n",
            "        [0.6140, 0.6834, 0.3323],\n",
            "        [0.5462, 0.8163, 0.9566]])\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0PQ-HRhOGipR",
        "colab_type": "text"
      },
      "source": [
        "### Operations\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jWNNdss0GQG6",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 527
        },
        "outputId": "ff03da2a-a4c6-4296-9db9-83901793d591"
      },
      "source": [
        "new_tensor = torch.rand(5, 3)\n",
        "simple_addition = old_tensor + new_tensor\n",
        "torch_add = torch.add(old_tensor, new_tensor)\n",
        "output_tensor_as_argument = torch.empty(5, 3)\n",
        "torch.add(old_tensor, new_tensor, out=output_tensor_as_argument)\n",
        "inplace_addition = new_tensor.add_(old_tensor)\n",
        "\n",
        "print('x + y : \\n', simple_addition)\n",
        "print('\\n')\n",
        "print('torch.add() : \\n', torch_add)\n",
        "print('\\n')\n",
        "print('Output tensor as argument : \\n', output_tensor_as_argument)\n",
        "print('\\n')\n",
        "print('In-place addition : \\n', inplace_addition)"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "x + y : \n",
            " tensor([[1.9855, 1.2796, 1.9305],\n",
            "        [1.9259, 1.3387, 1.6248],\n",
            "        [1.9437, 1.8683, 1.1107],\n",
            "        [1.2303, 1.0151, 1.3394],\n",
            "        [1.0631, 1.6831, 1.7090]], dtype=torch.float64)\n",
            "\n",
            "\n",
            "torch.add() : \n",
            " tensor([[1.9855, 1.2796, 1.9305],\n",
            "        [1.9259, 1.3387, 1.6248],\n",
            "        [1.9437, 1.8683, 1.1107],\n",
            "        [1.2303, 1.0151, 1.3394],\n",
            "        [1.0631, 1.6831, 1.7090]], dtype=torch.float64)\n",
            "\n",
            "\n",
            "Output tensor as argument : \n",
            " tensor([[1.9855, 1.2796, 1.9305],\n",
            "        [1.9259, 1.3387, 1.6248],\n",
            "        [1.9437, 1.8683, 1.1107],\n",
            "        [1.2303, 1.0151, 1.3394],\n",
            "        [1.0631, 1.6831, 1.7090]])\n",
            "\n",
            "\n",
            "In-place addition : \n",
            " tensor([[1.9855, 1.2796, 1.9305],\n",
            "        [1.9259, 1.3387, 1.6248],\n",
            "        [1.9437, 1.8683, 1.1107],\n",
            "        [1.2303, 1.0151, 1.3394],\n",
            "        [1.0631, 1.6831, 1.7090]])\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IrSKy7ihIzwX",
        "colab_type": "text"
      },
      "source": [
        "### Indexing Tensors\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CF5OYUUAI20F",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "9310bfa8-78e4-4a87-8e05-7ee41c92f84c"
      },
      "source": [
        "print('Print first row : \\n', new_tensor[:, 1])"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Print first row : \n",
            " tensor([1.2796, 1.3387, 1.8683, 1.0151, 1.6831])\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-4O_IGpVJr07",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 238
        },
        "outputId": "c492ddaa-cc40-4278-84ff-fdea1398c5b0"
      },
      "source": [
        "four_by_four_tensor = torch.rand(4, 4)\n",
        "resized_tensor = four_by_four_tensor.view(16)\n",
        "new_resized_tensor = resized_tensor.view(-1, 8)\n",
        "one_element = torch.rand(1)\n",
        "indexing_one_element = one_element.item() \n",
        "\n",
        "print('four_by_four_tensor : \\n', four_by_four_tensor, four_by_four_tensor.size())\n",
        "print('\\nresized_tensor : ', resized_tensor, resized_tensor.size())\n",
        "print('\\nnew resized_tensor : ', new_resized_tensor, new_resized_tensor.size())\n",
        "print('\\n Indexing tensor with one element only : ', one_element)"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "four_by_four_tensor : \n",
            " tensor([[0.0967, 0.3639, 0.2226, 0.1716],\n",
            "        [0.5799, 0.6646, 0.5323, 0.0392],\n",
            "        [0.9341, 0.1982, 0.9859, 0.1644],\n",
            "        [0.1394, 0.9150, 0.9714, 0.4409]]) torch.Size([4, 4])\n",
            "\n",
            "resized_tensor :  tensor([0.0967, 0.3639, 0.2226, 0.1716, 0.5799, 0.6646, 0.5323, 0.0392, 0.9341,\n",
            "        0.1982, 0.9859, 0.1644, 0.1394, 0.9150, 0.9714, 0.4409]) torch.Size([16])\n",
            "\n",
            "new resized_tensor :  tensor([[0.0967, 0.3639, 0.2226, 0.1716, 0.5799, 0.6646, 0.5323, 0.0392],\n",
            "        [0.9341, 0.1982, 0.9859, 0.1644, 0.1394, 0.9150, 0.9714, 0.4409]]) torch.Size([2, 8])\n",
            "\n",
            " Indexing tensor with one element only :  tensor([0.5945])\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "srp4FTkwLMHh",
        "colab_type": "text"
      },
      "source": [
        "### NumPy Bridge\n",
        "Converting a Torch Tensor to a NumPy array and vice versa."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gU9Zo7sBLRPf",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 204
        },
        "outputId": "ec12eb65-3c13-4b31-ead8-470e91427f06"
      },
      "source": [
        "import numpy as np\n",
        "\n",
        "torch_array = torch.rand(5)\n",
        "print('Original torch array : \\n', torch_array)\n",
        "\n",
        "torch_to_numpy = torch_array.numpy()\n",
        "print('\\nTorch array converted to numpy : \\n', torch_to_numpy)\n",
        "\n",
        "numpy_array = np.ones(5)\n",
        "print('\\nOriginal numpy array : \\n', numpy_array)\n",
        "\n",
        "numpy_to_torch = torch.from_numpy(numpy_array)\n",
        "print('\\nNumpy array converted to torch : \\n', numpy_to_torch)\n",
        "\n",
        "\n"
      ],
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Original torch array : \n",
            " tensor([0.3167, 0.3007, 0.1896, 0.0640, 0.8503])\n",
            "\n",
            "Torch array converted to numpy : \n",
            " [0.31668967 0.30073845 0.18957937 0.06404227 0.85028934]\n",
            "\n",
            "Original numpy array : \n",
            " [1. 1. 1. 1. 1.]\n",
            "\n",
            "Numpy array converted to torch : \n",
            " tensor([1., 1., 1., 1., 1.], dtype=torch.float64)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_YwYr3kSMPiK",
        "colab_type": "text"
      },
      "source": [
        "### CUDA Tensors\n",
        "Tensors can be moved onto any device using the `.to` method."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YVMS9fvhMVbp",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 102
        },
        "outputId": "fa548046-cb44-4c4a-cd49-bbbd57ba0765"
      },
      "source": [
        "import torch\n",
        "\n",
        "if torch.cuda.is_available:\n",
        "  device = torch.device(\"cuda\")\n",
        "  new_tensor = torch.rand(1)\n",
        "  cuda_tensor = torch.ones_like(new_tensor, device=device)\n",
        "  non_cuda_tensor = new_tensor.to(device)\n",
        "  cuda_result = cuda_tensor + non_cuda_tensor\n",
        "  print('CUDA result : \\n', cuda_result)\n",
        "  cpu_result = cuda_result.to(\"cpu\", torch.double)\n",
        "  print('\\n CPU result : \\n', cpu_result)"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "CUDA result : \n",
            " tensor([1.8087], device='cuda:0')\n",
            "\n",
            " CPU result : \n",
            " tensor([1.8087], dtype=torch.float64)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rROrKNDpNllm",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}