00_Pytorch_Basics_p1.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "### I**ntroduction to the Tensor**"
      ],
      "metadata": {
        "id": "5-aH8V1sLGf0"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **`torch.tensor()`**"
      ],
      "metadata": {
        "id": "kPDLO85bbkU0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "print(torch.__version__)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JU52FQN_LnqZ",
        "outputId": "ff32ba8a-7252-460c-d415-d0302f06f629"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2.3.0+cu121\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### 1. Scalar"
      ],
      "metadata": {
        "id": "baECZF0_NJAN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "scalar = torch.tensor(5)\n",
        "\n",
        "print(scalar)\n",
        "print(type(scalar))\n",
        "print(scalar.ndim)  # Attribute used in NumPy\n",
        "print(scalar.dim()) # Method used in PyTorch\n",
        "print(scalar.item())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8KGqme09LOWy",
        "outputId": "36607f73-71c1-4507-8572-58e4b222f881"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor(5)\n",
            "<class 'torch.Tensor'>\n",
            "0\n",
            "0\n",
            "5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### 2. Vector"
      ],
      "metadata": {
        "id": "SCEFv05xNN8q"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "vector = torch.tensor([5, 5])\n",
        "\n",
        "print(vector)\n",
        "print(vector.dim())\n",
        "print(vector.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5kAhjUfBLPcE",
        "outputId": "8e79e735-ee56-48ad-84b2-d5ae616cc335"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([5, 5])\n",
            "1\n",
            "torch.Size([2])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### 3. Matrix"
      ],
      "metadata": {
        "id": "U1rkx1tlNvQL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "MATRIX = torch.tensor([[1, 2],\n",
        "                       [3, 4]])\n",
        "\n",
        "print(MATRIX)\n",
        "print(MATRIX.dim())\n",
        "print(MATRIX.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_wJhQwsiLPZI",
        "outputId": "9aebbbd5-3841-4f3e-b4a0-20764128d854"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([[1, 2],\n",
            "        [3, 4]])\n",
            "2\n",
            "torch.Size([2, 2])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### 4. Tensor"
      ],
      "metadata": {
        "id": "cxKTiFJjOUky"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "TENSOR = torch.tensor([[[1, 2, 3],\n",
        "                        [4, 5, 6],\n",
        "                        [7, 8, 9]]])\n",
        "\n",
        "print(TENSOR)\n",
        "print(TENSOR.dim())\n",
        "print(TENSOR.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3bJZ8y-5LPXE",
        "outputId": "254d06c4-8067-4aff-ec7c-c743f0e94d13"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([[[1, 2, 3],\n",
            "         [4, 5, 6],\n",
            "         [7, 8, 9]]])\n",
            "3\n",
            "torch.Size([1, 3, 3])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "- `dim = 0`, which refers to the `columns` $\\downarrow$\n",
        "\n",
        "- `dim = 1`, which refers to the `rows` $\\rightarrow$"
      ],
      "metadata": {
        "id": "i1XgIe4jjxn2"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "![tensor](https://static.javatpoint.com/tutorial/pytorch/images/pytorch-tensors.png)\n",
        "\n",
        "\n",
        "<br></br>\n",
        "\n",
        "![tensor](https://editor.analyticsvidhya.com/uploads/64798tensor.png)"
      ],
      "metadata": {
        "id": "IwYii_X5d8rz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "\n",
        "# 0-dimensional tensor (scalar)\n",
        "scalar_tensor = torch.tensor(42)\n",
        "print(\"Scalar tensor:\", scalar_tensor)\n",
        "print(\"Dimensions:\", scalar_tensor.dim())\n",
        "\n",
        "# 1-dimensional tensor (vector)\n",
        "vector_tensor = torch.tensor([1, 2, 3, 4])\n",
        "print(\"\\nVector tensor:\", vector_tensor)\n",
        "print(\"Dimensions:\", vector_tensor.dim())\n",
        "\n",
        "# 2-dimensional tensor (matrix)\n",
        "matrix_tensor = torch.tensor([[1, 2], [3, 4], [5, 6]])\n",
        "print(\"\\nMatrix tensor:\")\n",
        "print(matrix_tensor)\n",
        "print(\"Dimensions:\", matrix_tensor.dim())\n",
        "\n",
        "# 3-dimensional tensor\n",
        "tensor_3d = torch.tensor([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])\n",
        "print(\"\\n3D tensor:\")\n",
        "print(tensor_3d)\n",
        "print(\"Dimensions:\", tensor_3d.dim())\n",
        "\n",
        "# 4-dimensional tensor\n",
        "tensor_4d = torch.tensor([[[[1, 2], [3, 4]], [[5, 6], [7, 8]]], [[[9, 10], [11, 12]], [[13, 14], [15, 16]]]])\n",
        "print(\"\\n4D tensor:\")\n",
        "print(tensor_4d)\n",
        "print(\"Dimensions:\", tensor_4d.dim())\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UBAmNkujbuJM",
        "outputId": "d98e13d4-c5e9-4739-9aac-2588500c7802"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Scalar tensor: tensor(42)\n",
            "Dimensions: 0\n",
            "\n",
            "Vector tensor: tensor([1, 2, 3, 4])\n",
            "Dimensions: 1\n",
            "\n",
            "Matrix tensor:\n",
            "tensor([[1, 2],\n",
            "        [3, 4],\n",
            "        [5, 6]])\n",
            "Dimensions: 2\n",
            "\n",
            "3D tensor:\n",
            "tensor([[[1, 2],\n",
            "         [3, 4]],\n",
            "\n",
            "        [[5, 6],\n",
            "         [7, 8]]])\n",
            "Dimensions: 3\n",
            "\n",
            "4D tensor:\n",
            "tensor([[[[ 1,  2],\n",
            "          [ 3,  4]],\n",
            "\n",
            "         [[ 5,  6],\n",
            "          [ 7,  8]]],\n",
            "\n",
            "\n",
            "        [[[ 9, 10],\n",
            "          [11, 12]],\n",
            "\n",
            "         [[13, 14],\n",
            "          [15, 16]]]])\n",
            "Dimensions: 4\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **`torch.rand()`**"
      ],
      "metadata": {
        "id": "3ZaVDgI3PLQF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "random_tensor = torch.rand(3, 3)\n",
        "random_tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NIwu0FdGPK7p",
        "outputId": "e200bf3c-8add-44dc-f5df-fd61755dba97"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[0.6175, 0.4285, 0.4029],\n",
              "        [0.6709, 0.0934, 0.1047],\n",
              "        [0.4482, 0.7418, 0.2804]])"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Create an image tensor with similar shape to an image tensor\n",
        "rand_img_tensor = torch.rand(size=(3, 224, 224)) # color channels, height, width\n",
        "\n",
        "print(rand_img_tensor.ndim)\n",
        "print(rand_img_tensor.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "la0eGRfqPnLS",
        "outputId": "65618ead-65cb-4bc6-9e45-46b633f9df40"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3\n",
            "torch.Size([3, 224, 224])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### `torch.zeros()` & `torch.ones()`\n",
        "\n"
      ],
      "metadata": {
        "id": "J94X0ulaQf1j"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "zeros = torch.zeros(size=(3, 4))\n",
        "zeros"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OdBqGuE8Qy2F",
        "outputId": "5c6b3721-94bf-4020-c3e5-142b43f6bfb0"
      },
      "execution_count": null,
      "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": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "ones = torch.ones(size=(3, 4))\n",
        "ones"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "heOTaPC9Q9_V",
        "outputId": "38981f7d-194f-4477-a2f6-f2acfcabff0e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[1., 1., 1., 1.],\n",
              "        [1., 1., 1., 1.],\n",
              "        [1., 1., 1., 1.]])"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### `torch.dtype()`"
      ],
      "metadata": {
        "id": "n9G9YP0BRscr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(scalar.dtype)\n",
        "print(vector.dtype)\n",
        "print(MATRIX.dtype)\n",
        "print(TENSOR.dtype)\n",
        "print(zeros.dtype)\n",
        "print(ones.dtype)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hOwb1KdURJlR",
        "outputId": "eeefe4c8-f08f-422f-c8e2-7fe913c8f040"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.int64\n",
            "torch.int64\n",
            "torch.int64\n",
            "torch.int64\n",
            "torch.float32\n",
            "torch.float32\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Note:** The default data type for tensors in PyTorch is `torch.float32`"
      ],
      "metadata": {
        "id": "-PRvAInYa6QM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a tensor with specified dtype\n",
        "tensor_float16 = torch.tensor([1.0, 2.0, 3.0], dtype=torch.float16)\n",
        "tensor_float32 = torch.tensor([1.0, 2.0, 3.0])\n",
        "tensor_float64 = torch.tensor([1.0, 2.0, 3.0], dtype=torch.float64)\n",
        "\n",
        "print(tensor_float16.dtype)\n",
        "print(tensor_float32.dtype)\n",
        "print(tensor_float64.dtype)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8Mcjt-vrZ-kl",
        "outputId": "ded2e408-b39f-4a1d-ab4e-687430023658"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.float16\n",
            "torch.float32\n",
            "torch.float64\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### `torch.range(start=, end=, step=)`"
      ],
      "metadata": {
        "id": "BxNlk9acb5Aj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "torch.arange(start=1, end=11, step=1 )"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4hyEobqqcAX3",
        "outputId": "0c1638e7-714b-4e79-deb7-044909ceeb2a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10])"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **`torch.squeeze()`**\n",
        "\n",
        "Remove dimensions of size 1 from the shape of a tensor."
      ],
      "metadata": {
        "id": "25XoNByYU8X0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "\n",
        "# Create the input tensor\n",
        "input_tensor = torch.randn([32, 1, 28, 28], dtype=torch.float)\n",
        "\n",
        "# Squeeze the tensor along dimension 0\n",
        "squeezed_tensor = torch.squeeze(input_tensor, dim=0)\n",
        "\n",
        "print(\"Original tensor shape:\", input_tensor.shape)\n",
        "print(\"Squeezed tensor shape:\", squeezed_tensor.shape)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Xx3EIJQhnvWg",
        "outputId": "ae1edcd6-dd03-455d-ca8b-452934ea545c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Original tensor shape: torch.Size([32, 1, 28, 28])\n",
            "Squeezed tensor shape: torch.Size([32, 1, 28, 28])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "\n",
        "# Create the input tensor\n",
        "input_tensor = torch.randn([32, 1, 28, 28], dtype=torch.float)\n",
        "\n",
        "# Squeeze the tensor along dimension 1\n",
        "squeezed_tensor = torch.squeeze(input_tensor, dim=1)\n",
        "\n",
        "print(\"Original tensor shape:\", input_tensor.shape)\n",
        "print(\"Squeezed tensor shape:\", squeezed_tensor.shape)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4gVhw_NNVMKM",
        "outputId": "c7e42e5f-9ba2-430d-8912-c0536381183f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Original tensor shape: torch.Size([32, 1, 28, 28])\n",
            "Squeezed tensor shape: torch.Size([32, 28, 28])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "\n",
        "x = torch.randn(1, 2, 3, 4)\n",
        "squeezed_x = torch.squeeze(x, dim=0)\n",
        "print(squeezed_x.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "trmb27Q9oa9v",
        "outputId": "a0dbff66-3045-4336-9fb6-d38593781af7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([2, 3, 4])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **`torch.unsqueeze()`**\n",
        "\n",
        "This function directly available in `TensorFlow`. However, in other frameworks like `PyTorch`, unsqueeze is used to add a dimension of size 1 at a specified axis. In `TensorFlow`, a similar effect can be achieved using `tf.expand_dims`."
      ],
      "metadata": {
        "id": "cfeVn9J1YSJy"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**1. Grey Scale**"
      ],
      "metadata": {
        "id": "kewpofiKZR4R"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "input_tensor = torch.randn([32, 1, 28, 28], dtype=torch.float)\n",
        "print(\"Original size:\", input_tensor.size())\n",
        "\n",
        "first_tensor = input_tensor[0]\n",
        "print(\"Size before unsqueeze: \",first_tensor.shape)\n",
        "\n",
        "# unsqueeze_tensor_0 = torch.unsqueeze(x, 0)\n",
        "unsqueeze_tensor_0 = first_tensor.unsqueeze(dim=0)\n",
        "print(\"Size after unsqueeze at dim 0: \", unsqueeze_tensor_0.size())\n",
        "\n",
        "# unsqueeze_tensor_1 = torch.unsqueeze(x, 1)\n",
        "unsqueeze_tensor_1 = first_tensor.unsqueeze(dim=1)\n",
        "print(\"Size after unsqueeze at dim 1: \", unsqueeze_tensor_1.size())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tvyM7oqpVUcl",
        "outputId": "3dbbf8c6-3acf-4099-870e-dee3830a37d5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Original size: torch.Size([32, 1, 28, 28])\n",
            "Size before unsqueeze:  torch.Size([1, 28, 28])\n",
            "Size after unsqueeze at dim 0:  torch.Size([1, 1, 28, 28])\n",
            "Size after unsqueeze at dim 1:  torch.Size([1, 1, 28, 28])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The bottom two results are the same because both are adding a single batch dimension to a single-channel image. If first_tensor had more than one channel, the results of unsqueezing at different dimensions would be different. For example, if first_tensor was `[3, 28, 28]` (representing an `RGB` image), unsqueezing at dim 0 would result in `[1, 3, 28, 28]`, while unsqueezing at dim 1 would result in `[3, 1, 28, 28]`"
      ],
      "metadata": {
        "id": "YTn6oh-1X-qI"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Note:** `unsqueeze_tensor_2 = x.unsqueeze(2)`\n",
        "\n",
        "- This will raise an IndexError as we are attemptting to unsqueeze the tensor at a dimension index that doesn’t exist for the given tensor."
      ],
      "metadata": {
        "id": "HBjB739bUVVD"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**2. RGB**"
      ],
      "metadata": {
        "id": "D5EJTIH0ZYf4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Example: Unsqueeze a tensor\n",
        "input_tensor = torch.randn([32, 3, 28, 28], dtype=torch.float)\n",
        "print(\"Original batch size:\", input_tensor.size())\n",
        "\n",
        "first_tensor = input_tensor[0]\n",
        "print(\"Size before unsqueeze: \", first_tensor.shape)\n",
        "\n",
        "# unsqueeze_tensor_0 = torch.unsqueeze(x, 0)\n",
        "unsqueeze_tensor_0 = first_tensor.unsqueeze(dim=0)\n",
        "print(\"Size after unsqueeze at dim 0: \", unsqueeze_tensor_0.size())\n",
        "\n",
        "# unsqueeze_tensor_1 = torch.unsqueeze(x, 1)\n",
        "unsqueeze_tensor_1 = first_tensor.unsqueeze(dim=1)\n",
        "print(\"Size after unsqueeze at dim 1: \", unsqueeze_tensor_1.size())\n",
        "\n",
        "# unsqueeze_tensor_1 = torch.unsqueeze(x, 1)\n",
        "unsqueeze_tensor_2 = first_tensor.unsqueeze(dim=2)\n",
        "print(\"Size after unsqueeze at dim 1: \", unsqueeze_tensor_2.size())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AmO_5VJWTGrj",
        "outputId": "19387393-c613-403c-8828-65da6042bcc9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Original batch size: torch.Size([32, 3, 28, 28])\n",
            "Size before unsqueeze:  torch.Size([3, 28, 28])\n",
            "Size after unsqueeze at dim 0:  torch.Size([1, 3, 28, 28])\n",
            "Size after unsqueeze at dim 1:  torch.Size([3, 1, 28, 28])\n",
            "Size after unsqueeze at dim 1:  torch.Size([3, 28, 1, 28])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### `argmax()`\n",
        "\n",
        "- To get the indices of the maximum values"
      ],
      "metadata": {
        "id": "P56F_ApeeYQH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "\n",
        "# Simulated output scores from a neural network for 3 classes (cat, dog, bird)\n",
        "y_pred = torch.tensor([[1.2, 0.9, 0.3, 0.4],\n",
        "                       [0.2, 2.1, 1.8, 3.1],\n",
        "                       [0.1, 1.5, 2.2, 2.1]])\n",
        "\n",
        "# Applying argmax to get the indices of the maximum values along dimension\n",
        "predicted_classes_0 = torch.argmax(y_pred, dim=0) # Applies argmax along dimension 0, which refers to the columns\n",
        "predicted_classes_1 = torch.argmax(y_pred, dim=1) # Applies argmax along dimension 1, referring to the rows\n",
        "\n",
        "print(predicted_classes_0)\n",
        "print(predicted_classes_1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZsJUeTF4eadO",
        "outputId": "ba9aa201-05fb-4f7c-d3c0-11040366c184"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([0, 1, 2, 1])\n",
            "tensor([0, 3, 2])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **`torch.cat()`**\n",
        "\n",
        "- Concatenating tensors along a specified dimension."
      ],
      "metadata": {
        "id": "nWcx_QWneV80"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "\n",
        "# Create two tensors\n",
        "tensor1 = torch.tensor([[1, 2], [3, 4]])\n",
        "tensor2 = torch.tensor([[5, 6], [7, 8]])\n",
        "\n",
        "# Concatenate along dimension 0 (rows)\n",
        "concatenated_tensor = torch.cat((tensor1, tensor2), dim=0)\n",
        "print(\"Concatenated tensor along dimension 0:\\n\", concatenated_tensor)\n",
        "\n",
        "# Concatenate along dimension 1 (columns)\n",
        "concatenated_tensor_dim1 = torch.cat((tensor1, tensor2), dim=1)\n",
        "print(\"Concatenated tensor along dimension 1:\\n\", concatenated_tensor_dim1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "P87kD6FBeRh1",
        "outputId": "fa4db007-114d-48bb-cdf6-6c8c53418933"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Concatenated tensor along dimension 0:\n",
            " tensor([[1, 2],\n",
            "        [3, 4],\n",
            "        [5, 6],\n",
            "        [7, 8]])\n",
            "Concatenated tensor along dimension 1:\n",
            " tensor([[1, 2, 5, 6],\n",
            "        [3, 4, 7, 8]])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **`torch.flatten()`**"
      ],
      "metadata": {
        "id": "h1l6DP4tf83t"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "\n",
        "# Create two tensors\n",
        "tensor1 = torch.tensor([[1, 2], [3, 4]])\n",
        "tensor2 = torch.tensor([[5, 6], [7, 8]])\n",
        "\n",
        "# Assuming concatenated_tensor_dim1 is already defined from the previous example\n",
        "concatenated_tensor_dim0 = torch.cat((tensor1, tensor2), dim=0)\n",
        "concatenated_tensor_dim1 = torch.cat((tensor1, tensor2), dim=1)\n",
        "\n",
        "# Flatten the concatenated tensor\n",
        "flat_tensor0 = torch.flatten(concatenated_tensor_dim0)\n",
        "flat_tensor1 = torch.flatten(concatenated_tensor_dim1)\n",
        "\n",
        "print(\"Flattened tensor 0:\\n\", flat_tensor0)\n",
        "print(\"Flattened tensor 1:\\n\", flat_tensor1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vIEFjqJGfgjN",
        "outputId": "69f136e0-b430-4ad6-81c8-e40ff1cb88c6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Flattened tensor 0:\n",
            " tensor([1, 2, 3, 4, 5, 6, 7, 8])\n",
            "Flattened tensor 1:\n",
            " tensor([1, 2, 5, 6, 3, 4, 7, 8])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **`torch.stack()`**"
      ],
      "metadata": {
        "id": "RCUFq_wvXOEP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "\n",
        "# Create two tensors\n",
        "tensor1 = torch.tensor([[1, 2], [3, 4]])\n",
        "tensor2 = torch.tensor([[5, 6], [7, 8]])\n",
        "\n",
        "# Stack tensors along a new dimension (dimension 0)\n",
        "stacked_tensor0 = torch.stack((tensor1, tensor2), dim=0)\n",
        "stacked_tensor1 = torch.stack((tensor1, tensor2), dim=1)\n",
        "\n",
        "print(\"Stacked tensor along dimension 0:\\n\", stacked_tensor0)\n",
        "print(\"\\n\")\n",
        "print(\"Stacked tensor along dimension 1:\\n\", stacked_tensor1)"
      ],
      "metadata": {
        "id": "_pj7Dbg6gIZ2",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5cb3308b-e04a-46c6-8fd6-ee4708a62cf6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Stacked tensor along dimension 0:\n",
            " tensor([[[1, 2],\n",
            "         [3, 4]],\n",
            "\n",
            "        [[5, 6],\n",
            "         [7, 8]]])\n",
            "\n",
            "\n",
            "Stacked tensor along dimension 1:\n",
            " tensor([[[1, 2],\n",
            "         [5, 6]],\n",
            "\n",
            "        [[3, 4],\n",
            "         [7, 8]]])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### `torch.isclose()` & `torch.eq()`"
      ],
      "metadata": {
        "id": "VjqRycSTdudR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "\n",
        "# Define two tensors\n",
        "tensor1 = torch.tensor([1.0, 2.0, 3.0])\n",
        "tensor2 = torch.tensor([1.1, 2.2, 3.3])\n",
        "\n",
        "# Check if the tensors are close within a tolerance of 0.2\n",
        "close_tensors = torch.isclose(tensor1, tensor2, atol=0.2)\n",
        "\n",
        "print(close_tensors)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vERAUpqedgML",
        "outputId": "3abde215-1149-46f7-bcc1-d5595653b05b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([ True,  True, False])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "\n",
        "# Define two tensors\n",
        "tensor1 = torch.tensor([1, 2, 3])\n",
        "tensor2 = torch.tensor([1, 2, 4])\n",
        "\n",
        "# Check for exact equality\n",
        "equal_tensors = torch.eq(tensor1, tensor2)\n",
        "\n",
        "print(equal_tensors)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LXHjlirndrLC",
        "outputId": "6ed5f0c9-dbb1-4360-b773-e80b47125efd"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([ True,  True, False])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        ">NOTE: Unlike `torch.isclose`, `torch.eq` does not have a `tolerance` parameter because it strictly checks for exact equality. It's useful when you need to perform element-wise comparisons where exact matches are required."
      ],
      "metadata": {
        "id": "348RL3qfd7gC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "\n",
        "# Define two tensors\n",
        "tensor1 = torch.tensor([1.001, 2.002, 3.003])\n",
        "tensor2 = torch.tensor([1.0, 2.0, 3.0])\n",
        "\n",
        "# Check for approximate equality with tolerance\n",
        "close_tensors = torch.isclose(tensor1, tensor2, atol=0.01)\n",
        "\n",
        "# Check for exact equality\n",
        "equal_tensors = torch.eq(tensor1, tensor2)\n",
        "\n",
        "print(\"Approximate equality with tolerance:\")\n",
        "print(close_tensors)\n",
        "\n",
        "print(\"\\nExact equality:\")\n",
        "print(equal_tensors)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iPJ0xQL0eMfp",
        "outputId": "adf60a42-109e-4a04-e5d4-40636880449b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Approximate equality with tolerance:\n",
            "tensor([True, True, True])\n",
            "\n",
            "Exact equality:\n",
            "tensor([False, False, False])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Counting number of cpu**"
      ],
      "metadata": {
        "id": "W6ft_nxey1nO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "os.cpu_count()"
      ],
      "metadata": {
        "id": "tolISGYBy4hk",
        "outputId": "17a2016f-2395-4e6f-d57b-27a8b7733bb9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {},
          "execution_count": 26
        }
      ]
    }
  ]
}