00_Fundamentals.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyNzWbFXk/JCKF/YP2ox96Bh"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU",
    "gpuClass": "standard"
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "vMYFEbn3LB67",
        "outputId": "409967e0-ad5b-48d3-ca9d-c7d6c4c79ec1"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'1.13.1+cu116'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 1
        }
      ],
      "source": [
        "import torch\n",
        "torch. __version__\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Scaler"
      ],
      "metadata": {
        "id": "RUcD0oi6MX7L"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "scaler = torch.tensor(7)\n",
        "scaler, scaler.dtype, scaler.item(),scaler.ndim\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cJJTbajcMcXO",
        "outputId": "d555e68a-5107-4cfe-9ddd-67e27c1241bf"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor(7), torch.int64, 7, 0)"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Vector"
      ],
      "metadata": {
        "id": "eBO5LfpmNAO3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "vector = torch.tensor([10,10])\n",
        "vector.size()\n",
        "vector.dtype, vector.shape\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CUeO2-60NCio",
        "outputId": "469d28b2-6946-4f74-d608-9d1cb8f73b07"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(torch.int64, torch.Size([2]))"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "vector.ndim"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ccqS7ALhNvjd",
        "outputId": "6cfa956e-d163-4f14-bc75-d70f11a84dd4"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# MATRIX"
      ],
      "metadata": {
        "id": "rLwMUchhN3ZJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        " A = torch.tensor([[4,5,6,7],\n",
        "                   [9,5,4,2]])\n",
        " A.ndim, A.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TEMeDfh4N7dv",
        "outputId": "5cf531b1-a15f-49a7-a4bc-f3ca3077f750"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(2, torch.Size([2, 4]))"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "X= A[0,2]\n",
        "X"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OCDpgOf2OhcW",
        "outputId": "76dbbb20-1a75-46c6-b3d2-cbb9a1dd5664"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor(6)"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "TENSOR = torch.tensor([[[1,2,3,4]],\n",
        "                       [[5,6,7,8,]],\n",
        "                       [[10,11,12,13]]])\n",
        "TENSOR.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KoRKL3oxOwUa",
        "outputId": "c4aff746-c52d-4a65-a558-024f22c8df0d"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.Size([3, 1, 4])"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "A = TENSOR[:,:,3]\n",
        "A\n",
        "TENSOR.ndim"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6NtoOLYGP0Fn",
        "outputId": "5accda3e-541c-48b7-ad68-b692fd5ef346"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "B = torch.rand(size=(3,3,3))\n",
        "B"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xtz54oHCQgR7",
        "outputId": "87283212-7cc1-4b9c-878e-2a7c9524fd55"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[[0.1428, 0.9167, 0.5896],\n",
              "         [0.2341, 0.5873, 0.2534],\n",
              "         [0.2218, 0.8750, 0.2673]],\n",
              "\n",
              "        [[0.8787, 0.9915, 0.1815],\n",
              "         [0.4906, 0.3248, 0.2214],\n",
              "         [0.4042, 0.2391, 0.2447]],\n",
              "\n",
              "        [[0.6887, 0.0637, 0.9747],\n",
              "         [0.0995, 0.8360, 0.7304],\n",
              "         [0.8642, 0.4284, 0.9160]]])"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Matrix Multiplication"
      ],
      "metadata": {
        "id": "VtQsN8xRRp7q"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "C = torch.rand(size=(3,2))\n",
        "D = torch.rand(size=(2,3))\n",
        "E = torch.mm(C,D)\n",
        "print(f\"C is : {C}\")\n",
        "print(f\"\\n D is : {D}\")\n",
        "print(f\"\\n C * D is : {E}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZoU71EEQQ2Y1",
        "outputId": "523d5a97-f443-4ab4-a77a-657864087d82"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "C is : tensor([[0.6126, 0.1505],\n",
            "        [0.4040, 0.8134],\n",
            "        [0.4521, 0.3016]])\n",
            "\n",
            " D is : tensor([[0.4604, 0.0337, 0.7534],\n",
            "        [0.0832, 0.4258, 0.7890]])\n",
            "\n",
            " C * D is : tensor([[0.2945, 0.0848, 0.5803],\n",
            "        [0.2537, 0.3600, 0.9462],\n",
            "        [0.2332, 0.1437, 0.5786]])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#range\n",
        "range = torch.arange(1,10,1)\n",
        "range"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XbFJyPqAR0cY",
        "outputId": "0478c85b-d813-4267-e129-34e9ac2a90bc"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([1, 2, 3, 4, 5, 6, 7, 8, 9])"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "C.dtype, D.dtype, E.dtype"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DZo5rzm4SB92",
        "outputId": "4eb4b237-a384-48b7-8254-90913eb87c91"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(torch.float32, torch.float32, torch.float32)"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#ZEROS AND ONES\n",
        "one = torch.ones(size=(3,3))\n",
        "zeros = torch.zeros(size=(4,4))\n",
        "one, zeros"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sJ8CRrlHSIhU",
        "outputId": "1e41015a-94be-467d-df15-123d54f9cecb"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor([[1., 1., 1.],\n",
              "         [1., 1., 1.],\n",
              "         [1., 1., 1.]]), tensor([[0., 0., 0., 0.],\n",
              "         [0., 0., 0., 0.],\n",
              "         [0., 0., 0., 0.],\n",
              "         [0., 0., 0., 0.]]))"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Tensor addito\n",
        "TENSOR + 10"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eRTtVx1pSkh5",
        "outputId": "89115961-1593-433d-9bbf-ad29486d9d78"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[[11, 12, 13, 14]],\n",
              "\n",
              "        [[15, 16, 17, 18]],\n",
              "\n",
              "        [[20, 21, 22, 23]]])"
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "TENSOR + TENSOR"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5sFnMm-NSvsH",
        "outputId": "685a4082-2fee-49be-b71b-28f1b58f1159"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[[ 2,  4,  6,  8]],\n",
              "\n",
              "        [[10, 12, 14, 16]],\n",
              "\n",
              "        [[20, 22, 24, 26]]])"
            ]
          },
          "metadata": {},
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# SUBTRACTION\n",
        "TENSOR - 5"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4wnq41ZrS3rM",
        "outputId": "fe96298d-5c71-4f5a-a44a-d3ff5fb72056"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[[-4, -3, -2, -1]],\n",
              "\n",
              "        [[ 0,  1,  2,  3]],\n",
              "\n",
              "        [[ 5,  6,  7,  8]]])"
            ]
          },
          "metadata": {},
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "TENSOR - TENSOR"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_ZXPmNgsS-RX",
        "outputId": "3b564868-9e8d-4525-98ec-854b572fcbb5"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[[0, 0, 0, 0]],\n",
              "\n",
              "        [[0, 0, 0, 0]],\n",
              "\n",
              "        [[0, 0, 0, 0]]])"
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#MULTIPLICATON\n",
        "TENSOR * 10"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "W1aKqmp4TDXj",
        "outputId": "fb1ea6f7-5858-4134-9ef8-29bab437631a"
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[[ 10,  20,  30,  40]],\n",
              "\n",
              "        [[ 50,  60,  70,  80]],\n",
              "\n",
              "        [[100, 110, 120, 130]]])"
            ]
          },
          "metadata": {},
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Transpose\n",
        "print(f\"ORIGINAL TENSOR:\\n {TENSOR}\")\n",
        "print(f\"Tranposed TENOSR:\\n {TENSOR.T}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "p2MySRhoTjBj",
        "outputId": "b033b1c3-332f-4af4-e457-c18e2f16d870"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "ORIGINAL TENSOR:\n",
            " tensor([[[ 1,  2,  3,  4]],\n",
            "\n",
            "        [[ 5,  6,  7,  8]],\n",
            "\n",
            "        [[10, 11, 12, 13]]])\n",
            "Tranposed TENOSR:\n",
            " tensor([[[ 1,  5, 10]],\n",
            "\n",
            "        [[ 2,  6, 11]],\n",
            "\n",
            "        [[ 3,  7, 12]],\n",
            "\n",
            "        [[ 4,  8, 13]]])\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-19-a1258bb001c3>:3: UserWarning: The use of `x.T` on tensors of dimension other than 2 to reverse their shape is deprecated and it will throw an error in a future release. Consider `x.mT` to transpose batches of matrices or `x.permute(*torch.arange(x.ndim - 1, -1, -1))` to reverse the dimensions of a tensor. (Triggered internally at ../aten/src/ATen/native/TensorShape.cpp:3277.)\n",
            "  print(f\"Tranposed TENOSR:\\n {TENSOR.T}\")\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#min\n",
        "TENSOR.min()\n",
        "torch.min(TENSOR)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yoq4pRxBUiFT",
        "outputId": "901c407b-c266-4914-8c79-8226e065cb58"
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor(1)"
            ]
          },
          "metadata": {},
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#mean\n",
        "torch.mean(TENSOR,dtype= torch.float32)\n",
        "TENSOR.type(torch.float32).mean()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TCpu3Q1HUylV",
        "outputId": "527c64e6-569a-4dc9-f892-4ba7b3ecf1b1"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor(6.8333)"
            ]
          },
          "metadata": {},
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#max\n",
        "TENSOR.max(), TENSOR.argmax()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6gv6qcqYUonN",
        "outputId": "6ff8a7d6-cc00-4679-aa0a-36ee6622d14a"
      },
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor(13), tensor(11))"
            ]
          },
          "metadata": {},
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "TENSOR\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rKMXd3Z-Vuvt",
        "outputId": "8dffd6cc-3b93-4f57-e7ff-170b35ed1d68"
      },
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[[ 1,  2,  3,  4]],\n",
              "\n",
              "        [[ 5,  6,  7,  8]],\n",
              "\n",
              "        [[10, 11, 12, 13]]])"
            ]
          },
          "metadata": {},
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "TENSOR.dtype"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "G6bLK6VzXXXx",
        "outputId": "f48c5cd5-665c-434b-b8a4-e7d064465d9a"
      },
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.int64"
            ]
          },
          "metadata": {},
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "### ERROR TO BE SOLVED LATER\n",
        "T = TENSOR.type(torch.int32)\n",
        "T.dtype"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Oy5mb4KOXbE8",
        "outputId": "7a3731a5-f6cc-4a5e-faea-bc7ac4be0a1f"
      },
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.int32"
            ]
          },
          "metadata": {},
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!nvidia-smi\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RZDW1fBaXvMs",
        "outputId": "9ef6e98a-e224-44e8-b99c-80babe5cf7a3"
      },
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Wed Feb  8 07:10:31 2023       \n",
            "+-----------------------------------------------------------------------------+\n",
            "| NVIDIA-SMI 510.47.03    Driver Version: 510.47.03    CUDA Version: 11.6     |\n",
            "|-------------------------------+----------------------+----------------------+\n",
            "| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n",
            "| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n",
            "|                               |                      |               MIG M. |\n",
            "|===============================+======================+======================|\n",
            "|   0  Tesla T4            Off  | 00000000:00:04.0 Off |                    0 |\n",
            "| N/A   64C    P0    29W /  70W |      0MiB / 15360MiB |      0%      Default |\n",
            "|                               |                      |                  N/A |\n",
            "+-------------------------------+----------------------+----------------------+\n",
            "                                                                               \n",
            "+-----------------------------------------------------------------------------+\n",
            "| Processes:                                                                  |\n",
            "|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\n",
            "|        ID   ID                                                   Usage      |\n",
            "|=============================================================================|\n",
            "|  No running processes found                                                 |\n",
            "+-----------------------------------------------------------------------------+\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "torch.cuda.is_available()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sGIyv0S4wtkA",
        "outputId": "b46bfe80-3271-4a96-d979-9378f24a8fcf"
      },
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# putting tensors and models on the gpu"
      ],
      "metadata": {
        "id": "8Os4KkKCx1j9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "device = 'cuda' if torch.cuda.is_available () else \"cpu\"\n",
        "device"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "ciEaqQi6yoTe",
        "outputId": "b61f731a-531f-4726-ba9e-100b5965f3fb"
      },
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'cuda'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "tensor = torch.tensor([1,2,5])\n",
        "print (tensor, tensor.device)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dhZ3aggDxlbc",
        "outputId": "879e2aa0-bda6-4f34-ddc8-3adc714a96e2"
      },
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([1, 2, 5]) cpu\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#move from cpu to cuda\n",
        "tensor_on_gpu = tensor.to(device)\n",
        "tensor_on_gpu"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PUmLWfoZy2eY",
        "outputId": "6a17eabe-c464-47af-f17b-9beace3ace90"
      },
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([1, 2, 5], device='cuda:0')"
            ]
          },
          "metadata": {},
          "execution_count": 30
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## moving tensor back to gpu"
      ],
      "metadata": {
        "id": "KQJbezaMzHca"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#if tensor is on gpu cant transform it to numpy\n",
        "tensor_on_gpu.numpy()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 183
        },
        "id": "xSfg3tb3zMD-",
        "outputId": "d145dc65-415a-41eb-80fd-6d125e0d2264"
      },
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-33-1c0977ef4ce4>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m#if tensor is on gpu cant transform it to numpy\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mtensor_on_gpu\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnumpy\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;31mTypeError\u001b[0m: can't convert cuda:0 device type tensor to numpy. Use Tensor.cpu() to copy the tensor to host memory first."
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# to fix the above error\n",
        "tensor_back_on_cpu = tensor_on_gpu.cpu().numpy()\n",
        "tensor_back_on_cpu"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_cEjdBZFzh0q",
        "outputId": "54144a30-7461-4363-a2d8-9f8434394490"
      },
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1, 2, 5])"
            ]
          },
          "metadata": {},
          "execution_count": 34
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Reshaping, stacking, squeezing and unsqueezing"
      ],
      "metadata": {
        "id": "LsFi7vs12aLV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Reshaping\n",
        "Reshape = torch.tensor([[1,2,3,4],\n",
        "                        [5,6,7,8],\n",
        "                        [10,11,12,13]])\n",
        "Reshape.size(), Reshape.shape, Reshape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hKPl1Y-j2it-",
        "outputId": "f895dc48-8773-4efe-9519-0c010f951f0f"
      },
      "execution_count": 36,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(torch.Size([3, 4]), torch.Size([3, 4]), tensor([[ 1,  2,  3,  4],\n",
              "         [ 5,  6,  7,  8],\n",
              "         [10, 11, 12, 13]]))"
            ]
          },
          "metadata": {},
          "execution_count": 36
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Reshape now\n",
        "Reshaped = torch.reshape(Reshape, [6,2])\n",
        "Reshaped"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cMsEeMD53bae",
        "outputId": "8cafe65b-48f5-4c05-a5d3-cdb3f6192caa"
      },
      "execution_count": 39,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[ 1,  2],\n",
              "        [ 3,  4],\n",
              "        [ 5,  6],\n",
              "        [ 7,  8],\n",
              "        [10, 11],\n",
              "        [12, 13]])"
            ]
          },
          "metadata": {},
          "execution_count": 39
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Stacking\n",
        "x2 = torch.tensor([1,2,3,4])\n",
        "stacked = torch.stack([x2,x2,x2,x2],dim=0)\n",
        "stacked"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LG1LTlbz36To",
        "outputId": "9fd7ccdb-b9e5-4e18-af38-c74faf11ecf5"
      },
      "execution_count": 50,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[1, 2, 3, 4],\n",
              "        [1, 2, 3, 4],\n",
              "        [1, 2, 3, 4],\n",
              "        [1, 2, 3, 4]])"
            ]
          },
          "metadata": {},
          "execution_count": 50
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#unsqueeze adds one dim\n",
        "unsqueezed = Reshape.unsqueeze(dim=1)\n",
        "unsqueezed"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "j9y5CINI5IbB",
        "outputId": "a9ce1afc-f6c9-4282-a769-9f904a13d20e"
      },
      "execution_count": 53,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[[ 1,  2,  3,  4]],\n",
              "\n",
              "        [[ 5,  6,  7,  8]],\n",
              "\n",
              "        [[10, 11, 12, 13]]])"
            ]
          },
          "metadata": {},
          "execution_count": 53
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "squeezed = unsqueezed.squeeze()\n",
        "squeezed"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zaArz0G25iRH",
        "outputId": "96007cd3-22ea-4858-8d37-c6bfcf24f605"
      },
      "execution_count": 55,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[ 1,  2,  3,  4],\n",
              "        [ 5,  6,  7,  8],\n",
              "        [10, 11, 12, 13]])"
            ]
          },
          "metadata": {},
          "execution_count": 55
        }
      ]
    }
  ]
}