01_pytorch_workflow_exercises.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "01_pytorch_workflow_exercises.ipynb",
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "gpuClass": "standard"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/E1250/ZTM-Courses/blob/main/01_pytorch_workflow_exercises.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 01. PyTorch Workflow Exercise Template\n",
        "\n",
        "The following is a template for the PyTorch workflow exercises.\n",
        "\n",
        "It's only starter code and it's your job to fill in the blanks.\n",
        "\n",
        "Because of the flexibility of PyTorch, there may be more than one way to answer the question.\n",
        "\n",
        "Don't worry about trying to be *right* just try writing code that suffices the question.\n",
        "\n",
        "You can see one form of [solutions on GitHub](https://github.com/mrdbourke/pytorch-deep-learning/tree/main/extras/solutions) (but try the exercises below yourself first!)."
      ],
      "metadata": {
        "id": "N8LsPXZti9Sw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Import necessary libraries\n",
        "import torch \n",
        "import torch.nn as nn\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import seaborn as sns\n",
        "\n",
        "%matplotlib inline\n",
        "sns.set()"
      ],
      "metadata": {
        "id": "Glu2fM4dkNlx"
      },
      "execution_count": 117,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Setup device-agnostic code\n",
        "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
        "device"
      ],
      "metadata": {
        "id": "LqKhXY26m31s",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "outputId": "2907a298-7b45-4f4b-cbd3-f752036414ae"
      },
      "execution_count": 118,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'cpu'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 118
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 1. Create a straight line dataset using the linear regression formula (`weight * X + bias`).\n",
        "  * Set `weight=0.3` and `bias=0.9` there should be at least 100 datapoints total. \n",
        "  * Split the data into 80% training, 20% testing.\n",
        "  * Plot the training and testing data so it becomes visual.\n",
        "\n",
        "Your output of the below cell should look something like:\n",
        "```\n",
        "Number of X samples: 100\n",
        "Number of y samples: 100\n",
        "First 10 X & y samples:\n",
        "X: tensor([0.0000, 0.0100, 0.0200, 0.0300, 0.0400, 0.0500, 0.0600, 0.0700, 0.0800,\n",
        "        0.0900])\n",
        "y: tensor([0.9000, 0.9030, 0.9060, 0.9090, 0.9120, 0.9150, 0.9180, 0.9210, 0.9240,\n",
        "        0.9270])\n",
        "```\n",
        "\n",
        "Of course the numbers in `X` and `y` may be different but ideally they're created using the linear regression formula."
      ],
      "metadata": {
        "id": "g7HUhxCxjeBx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create the data parameters\n",
        "weight = 0.3\n",
        "bias = 0.9\n",
        "\n",
        "start = 0\n",
        "end = 1\n",
        "step = 1/100\n",
        "\n",
        "X = torch.arange(start,end,step).unsqueeze(dim=1)\n",
        "y = weight*X+bias\n",
        "\n",
        "\n",
        "# Make X and y using linear regression feature\n",
        "print(f\"Number of X samples: {len(X)}\")\n",
        "print(f\"Number of y samples: {len(y)}\")\n",
        "print(f\"First 10 X & y samples:\\nX: {X[:10]}\\ny: {y[:10]}\")"
      ],
      "metadata": {
        "id": "KbDG5MV7jhvE",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "124b5084-57f8-45fc-9732-20971d823544"
      },
      "execution_count": 119,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Number of X samples: 100\n",
            "Number of y samples: 100\n",
            "First 10 X & y samples:\n",
            "X: tensor([[0.0000],\n",
            "        [0.0100],\n",
            "        [0.0200],\n",
            "        [0.0300],\n",
            "        [0.0400],\n",
            "        [0.0500],\n",
            "        [0.0600],\n",
            "        [0.0700],\n",
            "        [0.0800],\n",
            "        [0.0900]])\n",
            "y: tensor([[0.9000],\n",
            "        [0.9030],\n",
            "        [0.9060],\n",
            "        [0.9090],\n",
            "        [0.9120],\n",
            "        [0.9150],\n",
            "        [0.9180],\n",
            "        [0.9210],\n",
            "        [0.9240],\n",
            "        [0.9270]])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Split the data into training and testing\n",
        "split = int(0.8*len(X))\n",
        "\n",
        "X_train , y_train = X[:split],y[:split]\n",
        "X_test , y_test = X[split:],y[split:]\n",
        "\n",
        "len(X_train), len(X_test) ,len(y_train), len(y_test)"
      ],
      "metadata": {
        "id": "GlwtT1djkmLw",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f9bbc21b-ad59-44e0-a9fd-e2f1aab3e495"
      },
      "execution_count": 120,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(80, 20, 80, 20)"
            ]
          },
          "metadata": {},
          "execution_count": 120
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Plot the training and testing data\n",
        "\n",
        "def plotter(pred):\n",
        "  plt.figure(figsize = (10,7))\n",
        "  plt.scatter(X_train,y_train,c = 'b',s = 4,label = \"Training data\")\n",
        "  plt.scatter(X_test,y_test,c = 'g',s = 4,label = \"Test data\")\n",
        "\n",
        "  plt.scatter(X_test,pred,c = 'r',s = 4,label = \"Predictions\")"
      ],
      "metadata": {
        "id": "29iQZFNhlYJ-"
      },
      "execution_count": 121,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 2. Build a PyTorch model by subclassing `nn.Module`. \n",
        "  * Inside should be a randomly initialized `nn.Parameter()` with `requires_grad=True`, one for `weights` and one for `bias`. \n",
        "  * Implement the `forward()` method to compute the linear regression function you used to create the dataset in 1. \n",
        "  * Once you've constructed the model, make an instance of it and check its `state_dict()`.\n",
        "  * **Note:** If you'd like to use `nn.Linear()` instead of `nn.Parameter()` you can."
      ],
      "metadata": {
        "id": "ImZoe3v8jif8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create PyTorch linear regression model by subclassing nn.Module\n",
        "class LinearRegressionModel(nn.Module):\n",
        "  def __init__(self):\n",
        "    super(LinearRegressionModel, self).__init__()\n",
        "    self.linearModel = nn.Linear(in_features=1,out_features=1)\n",
        "  def forward(self,x:torch.Tensor) -> torch.Tensor:\n",
        "    return self.linearModel(x)"
      ],
      "metadata": {
        "id": "qzd__Y5rjtB8"
      },
      "execution_count": 122,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "> in this section i getting different Random Values , Which Creates a problem"
      ],
      "metadata": {
        "id": "SRW_PQWJmEY-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create PyTorch linear regression model by subclassing nn.Module\n",
        "## Option 1\n",
        "class LinearRegressionModel(nn.Module):\n",
        "  def __init__(self):\n",
        "    super().__init__()\n",
        "    self.weight = nn.Parameter(data=torch.randn(1, \n",
        "                                              requires_grad=True,\n",
        "                                              dtype=torch.float\n",
        "                                              ))\n",
        "    \n",
        "    self.bias = nn.Parameter(data=torch.randn(1, \n",
        "                                              requires_grad=True,\n",
        "                                              dtype=torch.float\n",
        "                                              ))\n",
        "\n",
        "  def forward(self, x):\n",
        "    return self.weight * x + self.bias\n",
        "  \n",
        "torch.manual_seed(42)\n",
        "model_1 = LinearRegressionModel()\n",
        "model_1,model_1.state_dict()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qcDit0p4l8KW",
        "outputId": "08846224-581d-4623-d7af-96adb85a459b"
      },
      "execution_count": 123,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(LinearRegressionModel(),\n",
              " OrderedDict([('weight', tensor([0.3367])), ('bias', tensor([0.1288]))]))"
            ]
          },
          "metadata": {},
          "execution_count": 123
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Instantiate the model and put it to the target device\n",
        "torch.manual_seed(42)\n",
        "model = LinearRegressionModel()\n",
        "model.to(device)\n",
        "model.state_dict()"
      ],
      "metadata": {
        "id": "5LdcDnmOmyQ2",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "daaa4448-68ec-408b-a58f-cdcc618f4528"
      },
      "execution_count": 124,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "OrderedDict([('weight', tensor([0.3367])), ('bias', tensor([0.1288]))])"
            ]
          },
          "metadata": {},
          "execution_count": 124
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 3. Create a loss function and optimizer using `nn.L1Loss()` and `torch.optim.SGD(params, lr)` respectively. \n",
        "  * Set the learning rate of the optimizer to be 0.01 and the parameters to optimize should be the model parameters from the model you created in 2.\n",
        "  * Write a training loop to perform the appropriate training steps for 300 epochs.\n",
        "  * The training loop should test the model on the test dataset every 20 epochs."
      ],
      "metadata": {
        "id": "G6nYOrJhjtfu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create the loss function and optimizer\n",
        "loss_fn = nn.L1Loss()\n",
        "optimizer = torch.optim.SGD(params=model.parameters(),lr = 0.01)"
      ],
      "metadata": {
        "id": "ltvoZ-FWjv1j"
      },
      "execution_count": 125,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Training loop\n",
        "torch.manual_seed(42)\n",
        "\n",
        "# Train model for 300 epochs\n",
        "epochs = 300\n",
        "\n",
        "\n",
        "# Send data to target device\n",
        "X_train.to(device)\n",
        "X_test.to(device)\n",
        "y_train.to(device)\n",
        "y_test.to(device)\n",
        "\n",
        "for epoch in range(epochs):\n",
        "  ### Training\n",
        "\n",
        "  # Put model in train mode\n",
        "  model.train()  \n",
        "\n",
        "  # 1. Forward pass\n",
        "  pred = model(X_train)\n",
        "\n",
        "  # 2. Calculate loss\n",
        "  loss = loss_fn(pred,y_train)\n",
        "\n",
        "  # 3. Zero gradients\n",
        "  optimizer.zero_grad()\n",
        "\n",
        "  # 4. Backpropagation\n",
        "  loss.backward()\n",
        "\n",
        "  # 5. Step the optimizer\n",
        "  optimizer.step()\n",
        "\n",
        "  ### Perform testing every 20 epochs\n",
        "  if epoch % 20 == 0:\n",
        "\n",
        "    # Put model in evaluation mode and setup inference context \n",
        "    model.eval()\n",
        "    with torch.inference_mode():\n",
        "      # 1. Forward pass\n",
        "      pred = model(X_test)\n",
        "      \n",
        "      # 2. Calculate test loss\n",
        "      test_loss = loss_fn(pred,y_test)\n",
        "\n",
        "      # Print out what's happening\n",
        "      print(f\"Epoch: {epoch} | Train loss: {loss:.3f} | Test loss: {test_loss:.3f}\")"
      ],
      "metadata": {
        "id": "xpE83NvNnkdV",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "50b3ce44-6b1a-4cb6-c395-aca25ad91aa4"
      },
      "execution_count": 126,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 0 | Train loss: 0.757 | Test loss: 0.725\n",
            "Epoch: 20 | Train loss: 0.525 | Test loss: 0.454\n",
            "Epoch: 40 | Train loss: 0.294 | Test loss: 0.183\n",
            "Epoch: 60 | Train loss: 0.077 | Test loss: 0.073\n",
            "Epoch: 80 | Train loss: 0.053 | Test loss: 0.116\n",
            "Epoch: 100 | Train loss: 0.046 | Test loss: 0.105\n",
            "Epoch: 120 | Train loss: 0.039 | Test loss: 0.089\n",
            "Epoch: 140 | Train loss: 0.032 | Test loss: 0.074\n",
            "Epoch: 160 | Train loss: 0.025 | Test loss: 0.058\n",
            "Epoch: 180 | Train loss: 0.018 | Test loss: 0.042\n",
            "Epoch: 200 | Train loss: 0.011 | Test loss: 0.026\n",
            "Epoch: 220 | Train loss: 0.004 | Test loss: 0.009\n",
            "Epoch: 240 | Train loss: 0.004 | Test loss: 0.006\n",
            "Epoch: 260 | Train loss: 0.004 | Test loss: 0.006\n",
            "Epoch: 280 | Train loss: 0.004 | Test loss: 0.006\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 4. Make predictions with the trained model on the test data.\n",
        "  * Visualize these predictions against the original training and testing data (**note:** you may need to make sure the predictions are *not* on the GPU if you want to use non-CUDA-enabled libraries such as matplotlib to plot)."
      ],
      "metadata": {
        "id": "x4j4TM18jwa7"
      }
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "gewulGfIk2H8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Make predictions with the model\n",
        "with torch.inference_mode():\n",
        "  pred = model(X_test)\n",
        "  print(pred)"
      ],
      "metadata": {
        "id": "bbMPK5Qjjyx_",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d2079845-7e5a-406c-b3fb-402e0879ff85"
      },
      "execution_count": 127,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([[1.1464],\n",
            "        [1.1495],\n",
            "        [1.1525],\n",
            "        [1.1556],\n",
            "        [1.1587],\n",
            "        [1.1617],\n",
            "        [1.1648],\n",
            "        [1.1679],\n",
            "        [1.1709],\n",
            "        [1.1740],\n",
            "        [1.1771],\n",
            "        [1.1801],\n",
            "        [1.1832],\n",
            "        [1.1863],\n",
            "        [1.1893],\n",
            "        [1.1924],\n",
            "        [1.1955],\n",
            "        [1.1985],\n",
            "        [1.2016],\n",
            "        [1.2047]])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Plot the predictions (these may need to be on a specific device)\n",
        "plotter(pred)"
      ],
      "metadata": {
        "id": "K3BdmQaDpFo8",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 431
        },
        "outputId": "7c1b5e23-b2bd-44d5-b23b-36c952628fe5"
      },
      "execution_count": 128,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 720x504 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 5. Save your trained model's `state_dict()` to file.\n",
        "  * Create a new instance of your model class you made in 2. and load in the `state_dict()` you just saved to it.\n",
        "  * Perform predictions on your test data with the loaded model and confirm they match the original model predictions from 4."
      ],
      "metadata": {
        "id": "s2OnlMWKjzX8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from pathlib import Path\n",
        "\n",
        "# 1. Create models directory \n",
        "DIR = Path('models')\n",
        "\n",
        "# 2. Create model save path \n",
        "DIR.mkdir(exist_ok=True,parents=True)\n",
        "FILE = DIR / \"model0.pth\"\n",
        "# 3. Save the model state dict\n",
        "torch.save(obj=model.state_dict(),f=FILE)"
      ],
      "metadata": {
        "id": "hgxhgD14qr-i"
      },
      "execution_count": 129,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Create new instance of model and load saved state dict (make sure to put it on the target device)\n",
        "loaded_model = LinearRegressionModel()\n",
        "loaded_model.load_state_dict(torch.load(f=FILE))\n",
        "loaded_model.to(device)\n"
      ],
      "metadata": {
        "id": "P9vTgiLRrJ7T",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7b6eea9f-218e-4df0-8867-6f53b58bbf07"
      },
      "execution_count": 130,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "LinearRegressionModel()"
            ]
          },
          "metadata": {},
          "execution_count": 130
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Make predictions with loaded model and compare them to the previous\n",
        "with torch.inference_mode():\n",
        "  loaded_model_pred = loaded_model(X_test)\n",
        "  plotter(loaded_model_pred)"
      ],
      "metadata": {
        "id": "8UGX3VebrVtI",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 431
        },
        "outputId": "8053c1ac-4576-4a3d-ea5d-83e2fb193995"
      },
      "execution_count": 131,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 720x504 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### I Faced simple problem with high effect, I used `plot` instead of `scatter` and it was so bad and unrepresentative, Didnt expect that maybe i have to read more about **Plotting**"
      ],
      "metadata": {
        "id": "X6KPJhgjqS6s"
      }
    }
  ]
}