Sequential_Model_Example.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4",
      "authorship_tag": "ABX9TyOfDiX6Ql88Ss0DqhvV6F8M",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/tanvirnwu/PyTorch--Python/blob/main/Sequential_Model_Example.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 71,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oGS0w629ZWZi",
        "outputId": "786f94d9-db57-44f4-8df9-118ea7f8a020"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: torch_summary in /usr/local/lib/python3.10/dist-packages (1.4.5)\n"
          ]
        }
      ],
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import numpy as np\n",
        "from torch.utils.data import Dataset, DataLoader\n",
        "!pip install torch_summary\n",
        "from torchsummary import summary\n",
        "from torch.optim import SGD\n",
        "import time"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
        "device"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "id": "N0nzLI0tZcV7",
        "outputId": "b91ef3bf-83b1-4d03-810d-2cf9779221df"
      },
      "execution_count": 72,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'cuda'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 72
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "class DataProcessing (Dataset):\n",
        "    def __init__(self, X, y):\n",
        "        self.X = torch.tensor(X).float().to(device)\n",
        "        self.y = torch.tensor(y).float().to(device)\n",
        "\n",
        "    def __getitem__(self, index):\n",
        "        return self.X[index], self.y[index]\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.X)"
      ],
      "metadata": {
        "id": "gTaj56hkZkQ_"
      },
      "execution_count": 73,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "X = np.random.randint(0, 10, size=(10, 2))\n",
        "X"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "idXkkIOZZlB7",
        "outputId": "eaf30d36-921e-4912-c0f8-b80dfb2ec697"
      },
      "execution_count": 74,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[6, 6],\n",
              "       [6, 8],\n",
              "       [9, 6],\n",
              "       [1, 0],\n",
              "       [9, 8],\n",
              "       [3, 3],\n",
              "       [4, 1],\n",
              "       [0, 5],\n",
              "       [7, 5],\n",
              "       [2, 1]])"
            ]
          },
          "metadata": {},
          "execution_count": 74
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Calculate the row-wise sum along axis=1\n",
        "row_sums = np.sum(X, axis=1)\n",
        "row_sums"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FPGCgQMAZmdt",
        "outputId": "ee2addad-48be-4bb7-94ed-38eb97ad01df"
      },
      "execution_count": 75,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([12, 14, 15,  1, 17,  6,  5,  5, 12,  3])"
            ]
          },
          "metadata": {},
          "execution_count": 75
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Reshape the row_sums array to have a column shape\n",
        "y = row_sums.reshape(-1, 1)\n",
        "y"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "guKWUWpRZn82",
        "outputId": "a5603b9e-0f5c-4e5c-a244-197f4138b79c"
      },
      "execution_count": 76,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[12],\n",
              "       [14],\n",
              "       [15],\n",
              "       [ 1],\n",
              "       [17],\n",
              "       [ 6],\n",
              "       [ 5],\n",
              "       [ 5],\n",
              "       [12],\n",
              "       [ 3]])"
            ]
          },
          "metadata": {},
          "execution_count": 76
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Create an object of the DataProcessing class\n",
        "dp = DataProcessing (X, y)\n",
        "dp[1], dp[0]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5WrSvaLMZpsD",
        "outputId": "ba03ea1d-3e13-4356-ff18-ce7caebb332d"
      },
      "execution_count": 77,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "((tensor([6., 8.], device='cuda:0'), tensor([14.], device='cuda:0')),\n",
              " (tensor([6., 6.], device='cuda:0'), tensor([12.], device='cuda:0')))"
            ]
          },
          "metadata": {},
          "execution_count": 77
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "dloader = DataLoader(dp, batch_size=2, shuffle=True)"
      ],
      "metadata": {
        "id": "gYhHguYKa0AD"
      },
      "execution_count": 78,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Creating a Sequential Model"
      ],
      "metadata": {
        "id": "jA8Xe4S3e7Jb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "model = nn.Sequential(\n",
        "        nn.Linear(2, 6),\n",
        "        nn.ReLU(),\n",
        "        nn.Linear(6, 1)\n",
        "        ).to(device)"
      ],
      "metadata": {
        "id": "He8l2wUyZrEn"
      },
      "execution_count": 79,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "summary(model, torch.zeros(1,2));"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HwHQc0oTZtJN",
        "outputId": "140a6bab-5304-4ed3-de3c-be415b2d3b55"
      },
      "execution_count": 80,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "==========================================================================================\n",
            "Layer (type:depth-idx)                   Output Shape              Param #\n",
            "==========================================================================================\n",
            "├─Linear: 1-1                            [-1, 6]                   18\n",
            "├─ReLU: 1-2                              [-1, 6]                   --\n",
            "├─Linear: 1-3                            [-1, 1]                   7\n",
            "==========================================================================================\n",
            "Total params: 25\n",
            "Trainable params: 25\n",
            "Non-trainable params: 0\n",
            "Total mult-adds (M): 0.00\n",
            "==========================================================================================\n",
            "Input size (MB): 0.00\n",
            "Forward/backward pass size (MB): 0.00\n",
            "Params size (MB): 0.00\n",
            "Estimated Total Size (MB): 0.00\n",
            "==========================================================================================\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Define a loss function and optimizer\n",
        "loss_func = nn.MSELoss()\n",
        "optimizer = SGD(model.parameters(), lr = 0.001)"
      ],
      "metadata": {
        "id": "E0Fef74FZwRi"
      },
      "execution_count": 81,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "loss_history = []\n",
        "start = time.time()\n",
        "\n",
        "for xx in range(50):\n",
        "  for X, y in dloader:\n",
        "    optimizer.zero_grad()\n",
        "    y_pred = model(X)\n",
        "    loss_value = loss_func(y_pred, y)\n",
        "    loss_value.backward()\n",
        "    optimizer.step()\n",
        "    loss_history.append(loss_value)\n",
        "\n",
        "end = time.time()\n",
        "print(f\"Total Training Time = {end-start}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "83gwG1F6Z7Qb",
        "outputId": "4d91343e-608e-4d1d-8734-c10d2e7c963a"
      },
      "execution_count": 82,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Total Training Time = 0.23036956787109375\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Creating Validation Set"
      ],
      "metadata": {
        "id": "fjRGRCJScdTF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "X_test = np.random.randint(0, 10, size=(10, 2))\n",
        "row_sums = np.sum(X_test, axis=1)\n",
        "row_sums"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9tD4L23dccqw",
        "outputId": "8f1159e6-8864-49a0-f831-b7931dc8f222"
      },
      "execution_count": 83,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([18,  5, 12, 14,  4,  9,  6, 10, 13, 11])"
            ]
          },
          "metadata": {},
          "execution_count": 83
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "X_test"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "s-Tc-Q79c2Yx",
        "outputId": "3735f8ca-9dfa-49de-93f3-60f1de7c50c8"
      },
      "execution_count": 84,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[9, 9],\n",
              "       [3, 2],\n",
              "       [8, 4],\n",
              "       [7, 7],\n",
              "       [4, 0],\n",
              "       [1, 8],\n",
              "       [2, 4],\n",
              "       [7, 3],\n",
              "       [9, 4],\n",
              "       [8, 3]])"
            ]
          },
          "metadata": {},
          "execution_count": 84
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Reshape the row_sums array to have a column shape\n",
        "y_test = row_sums.reshape(-1, 1)\n",
        "y_test"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1jQe1LczcwZP",
        "outputId": "f51f465d-fba5-436a-bc54-ff0379ab6eee"
      },
      "execution_count": 85,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[18],\n",
              "       [ 5],\n",
              "       [12],\n",
              "       [14],\n",
              "       [ 4],\n",
              "       [ 9],\n",
              "       [ 6],\n",
              "       [10],\n",
              "       [13],\n",
              "       [11]])"
            ]
          },
          "metadata": {},
          "execution_count": 85
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "X_test = torch.tensor(X_test).float().to(device)\n",
        "y_test = torch.tensor(y_test).float().to(device)\n",
        "X_test, y_test"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ohfF7nMubehG",
        "outputId": "86229924-0be3-41cc-a960-7d4806f42ffd"
      },
      "execution_count": 86,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor([[9., 9.],\n",
              "         [3., 2.],\n",
              "         [8., 4.],\n",
              "         [7., 7.],\n",
              "         [4., 0.],\n",
              "         [1., 8.],\n",
              "         [2., 4.],\n",
              "         [7., 3.],\n",
              "         [9., 4.],\n",
              "         [8., 3.]], device='cuda:0'),\n",
              " tensor([[18.],\n",
              "         [ 5.],\n",
              "         [12.],\n",
              "         [14.],\n",
              "         [ 4.],\n",
              "         [ 9.],\n",
              "         [ 6.],\n",
              "         [10.],\n",
              "         [13.],\n",
              "         [11.]], device='cuda:0'))"
            ]
          },
          "metadata": {},
          "execution_count": 86
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "y_test_pred = model(X_test)\n",
        "y_test_pred = y_test_pred.round().to(dtype=torch.int)\n",
        "y_test_pred"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xKGyCCBcbxkY",
        "outputId": "c6cfc707-c5ed-484c-ef11-3c7c6cd9744d"
      },
      "execution_count": 89,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[18],\n",
              "        [ 5],\n",
              "        [12],\n",
              "        [14],\n",
              "        [ 4],\n",
              "        [ 9],\n",
              "        [ 6],\n",
              "        [10],\n",
              "        [13],\n",
              "        [11]], device='cuda:0', dtype=torch.int32)"
            ]
          },
          "metadata": {},
          "execution_count": 89
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Accuracy"
      ],
      "metadata": {
        "id": "kGFMZHJReZIi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def calculate_accuracy(predicted_labels, true_labels):\n",
        "    # Convert predicted and true labels to numpy arrays if they are tensors\n",
        "    if torch.is_tensor(predicted_labels):\n",
        "        predicted_labels = predicted_labels.cpu().numpy()\n",
        "    if torch.is_tensor(true_labels):\n",
        "        true_labels = true_labels.cpu().numpy()\n",
        "\n",
        "    # Calculate accuracy\n",
        "    num_correct = (predicted_labels == true_labels).sum()\n",
        "    total_samples = len(true_labels)\n",
        "    accuracy = num_correct / total_samples\n",
        "\n",
        "    return accuracy"
      ],
      "metadata": {
        "id": "6PWRz_kKb_ZQ"
      },
      "execution_count": 90,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "accuracy = calculate_accuracy(y_test_pred, y_test)\n",
        "print(f\"Accuracy: {accuracy*100}%\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yZcscmAtejFc",
        "outputId": "7ebee8e2-5d4f-48b9-bd7d-3f859ab9cccc"
      },
      "execution_count": 94,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Accuracy: 100.0%\n"
          ]
        }
      ]
    }
  ]
}